| 1 | /* -*- Mode: C; tab-width: 4 -*- |
| 2 | * |
| 3 | * Copyright (c) 2002-2017 Apple Inc. All rights reserved. |
| 4 | * |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | * |
| 17 | * This code is completely 100% portable C. It does not depend on any external header files |
| 18 | * from outside the mDNS project -- all the types it expects to find are defined right here. |
| 19 | * |
| 20 | * The previous point is very important: This file does not depend on any external |
| 21 | * header files. It should compile on *any* platform that has a C compiler, without |
| 22 | * making *any* assumptions about availability of so-called "standard" C functions, |
| 23 | * routines, or types (which may or may not be present on any given platform). |
| 24 | */ |
| 25 | |
| 26 | #include "DNSCommon.h" // Defines general DNS utility routines |
| 27 | #include "uDNS.h" // Defines entry points into unicast-specific routines |
| 28 | #include "nsec.h" |
| 29 | #include "dnssec.h" |
| 30 | #include "anonymous.h" |
| 31 | |
| 32 | // Disable certain benign warnings with Microsoft compilers |
| 33 | #if (defined(_MSC_VER)) |
| 34 | // Disable "conditional expression is constant" warning for debug macros. |
| 35 | // Otherwise, this generates warnings for the perfectly natural construct "while(1)" |
| 36 | // If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know |
| 37 | #pragma warning(disable:4127) |
| 38 | |
| 39 | // Disable "assignment within conditional expression". |
| 40 | // Other compilers understand the convention that if you place the assignment expression within an extra pair |
| 41 | // of parentheses, this signals to the compiler that you really intended an assignment and no warning is necessary. |
| 42 | // The Microsoft compiler doesn't understand this convention, so in the absense of any other way to signal |
| 43 | // to the compiler that the assignment is intentional, we have to just turn this warning off completely. |
| 44 | #pragma warning(disable:4706) |
| 45 | #endif |
| 46 | |
| 47 | #include "dns_sd.h" // for kDNSServiceFlags* definitions |
| 48 | #include "dns_sd_internal.h" |
| 49 | |
| 50 | #define IID(a) ((int32_t)(intptr_t)(a)) |
| 51 | |
| 52 | #if APPLE_OSX_mDNSResponder |
| 53 | #include <WebFilterDNS/WebFilterDNS.h> |
| 54 | |
| 55 | // Delay in seconds before disabling multicast after there are no active queries or registrations. |
| 56 | #define BONJOUR_DISABLE_DELAY 60 |
| 57 | |
| 58 | #if !NO_WCF |
| 59 | WCFConnection *WCFConnectionNew(void) __attribute__((weak_import)); |
| 60 | void WCFConnectionDealloc(WCFConnection* c) __attribute__((weak_import)); |
| 61 | |
| 62 | // Do we really need to define a macro for "if"? |
| 63 | #define CHECK_WCF_FUNCTION(X) if (X) |
| 64 | #endif // ! NO_WCF |
| 65 | |
| 66 | #else |
| 67 | |
| 68 | #define NO_WCF 1 |
| 69 | #endif // APPLE_OSX_mDNSResponder |
| 70 | |
| 71 | #if AWD_METRICS |
| 72 | #include "Metrics.h" |
| 73 | #endif |
| 74 | |
| 75 | #if USE_DNS64 |
| 76 | #include "DNS64.h" |
| 77 | #endif |
| 78 | |
| 79 | #ifdef UNIT_TEST |
| 80 | #include "unittest.h" |
| 81 | #endif |
| 82 | |
| 83 | // Forward declarations |
| 84 | mDNSlocal void BeginSleepProcessing(mDNS *const m); |
| 85 | mDNSlocal void RetrySPSRegistrations(mDNS *const m); |
| 86 | mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password, mDNSBool unicastOnly); |
| 87 | mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q); |
| 88 | mDNSlocal void mDNS_PurgeForQuestion(mDNS *const m, DNSQuestion *q); |
| 89 | mDNSlocal void CheckForDNSSECRecords(mDNS *const m, DNSQuestion *q); |
| 90 | mDNSlocal void mDNS_SendKeepalives(mDNS *const m); |
| 91 | mDNSlocal void mDNS_ExtractKeepaliveInfo(AuthRecord *ar, mDNSu32 *timeout, mDNSAddr *laddr, mDNSAddr *raddr, mDNSEthAddr *eth, |
| 92 | mDNSu32 *seq, mDNSu32 *ack, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu16 *win); |
| 93 | |
| 94 | mDNSlocal void AdvertiseAllInterfaceRecords(mDNS *const m); |
| 95 | mDNSlocal void DeadvertiseAllInterfaceRecords(mDNS *const m); |
| 96 | mDNSlocal void FreeNSECRecords(mDNS *const m, CacheRecord *NSECRecords); |
| 97 | mDNSlocal void mDNSParseNSEC3Records(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, |
| 98 | const mDNSInterfaceID InterfaceID, CacheRecord **NSEC3Records); |
| 99 | mDNSlocal mDNSu8 *GetValueForMACAddr(mDNSu8 *ptr, mDNSu8 *limit, mDNSEthAddr *eth); |
| 100 | |
| 101 | |
| 102 | // *************************************************************************** |
| 103 | #if COMPILER_LIKES_PRAGMA_MARK |
| 104 | #pragma mark - Program Constants |
| 105 | #endif |
| 106 | |
| 107 | // To Turn OFF mDNS_Tracer set MDNS_TRACER to 0 or undef it |
| 108 | #define MDNS_TRACER 1 |
| 109 | |
| 110 | #define NO_HINFO 1 |
| 111 | |
| 112 | // Any records bigger than this are considered 'large' records |
| 113 | #define SmallRecordLimit 1024 |
| 114 | |
| 115 | #define kMaxUpdateCredits 10 |
| 116 | #define kUpdateCreditRefreshInterval (mDNSPlatformOneSecond * 6) |
| 117 | |
| 118 | // define special NR_AnswerTo values |
| 119 | #define NR_AnswerMulticast (mDNSu8*)~0 |
| 120 | #define NR_AnswerUnicast (mDNSu8*)~1 |
| 121 | |
| 122 | // Question default timeout values |
| 123 | #define DEFAULT_MCAST_TIMEOUT 5 |
| 124 | #define DEFAULT_LO_OR_P2P_TIMEOUT 5 |
| 125 | |
| 126 | // The code (see SendQueries() and BuildQuestion()) needs to have the |
| 127 | // RequestUnicast value set to a value one greater than the number of times you want the query |
| 128 | // sent with the "request unicast response" (QU) bit set. |
| 129 | #define SET_QU_IN_FIRST_QUERY 2 |
| 130 | #define kDefaultRequestUnicastCount SET_QU_IN_FIRST_QUERY |
| 131 | |
| 132 | // The time needed to offload records to a sleep proxy after powerd sends the kIOMessageSystemWillSleep notification |
| 133 | #define DARK_WAKE_DELAY_SLEEP 5 |
| 134 | #define kDarkWakeDelaySleep (mDNSPlatformOneSecond * DARK_WAKE_DELAY_SLEEP) |
| 135 | |
| 136 | // The maximum number of times we delay probing to prevent spurious conflicts due to stale packets |
| 137 | #define MAX_CONFLICT_PROCESSING_DELAYS 3 |
| 138 | |
| 139 | // RFC 6762 defines Passive Observation Of Failures (POOF) |
| 140 | // |
| 141 | // A host observes the multicast queries issued by the other hosts on |
| 142 | // the network. One of the major benefits of also sending responses |
| 143 | // using multicast is that it allows all hosts to see the responses |
| 144 | // (or lack thereof) to those queries. |
| 145 | // |
| 146 | // If a host sees queries, for which a record in its cache would be |
| 147 | // expected to be given as an answer in a multicast response, but no |
| 148 | // such answer is seen, then the host may take this as an indication |
| 149 | // that the record may no longer be valid. |
| 150 | // |
| 151 | // After seeing two or more of these queries, and seeing no multicast |
| 152 | // response containing the expected answer within ten seconds, then even |
| 153 | // though its TTL may indicate that it is not yet due to expire, that |
| 154 | // record SHOULD be flushed from the cache. |
| 155 | // |
| 156 | // <https://tools.ietf.org/html/rfc6762#section-10.5> |
| 157 | |
| 158 | #define POOF_ENABLED 1 |
| 159 | |
| 160 | mDNSexport const char *const mDNS_DomainTypeNames[] = |
| 161 | { |
| 162 | "b._dns-sd._udp." , // Browse |
| 163 | "db._dns-sd._udp." , // Default Browse |
| 164 | "lb._dns-sd._udp." , // Automatic Browse |
| 165 | "r._dns-sd._udp." , // Registration |
| 166 | "dr._dns-sd._udp." // Default Registration |
| 167 | }; |
| 168 | |
| 169 | #ifdef UNICAST_DISABLED |
| 170 | #define uDNS_IsActiveQuery(q, u) mDNSfalse |
| 171 | #endif |
| 172 | |
| 173 | // *************************************************************************** |
| 174 | #if COMPILER_LIKES_PRAGMA_MARK |
| 175 | #pragma mark - |
| 176 | #pragma mark - General Utility Functions |
| 177 | #endif |
| 178 | |
| 179 | // Returns true if this is a unique, authoritative LocalOnly record that answers questions of type |
| 180 | // A, AAAA , CNAME, or PTR. The caller should answer the question with this record and not send out |
| 181 | // the question on the wire if LocalOnlyRecordAnswersQuestion() also returns true. |
| 182 | // Main use is to handle /etc/hosts records and the LocalOnly PTR records created for localhost. |
| 183 | #define UniqueLocalOnlyRecord(rr) ((rr)->ARType == AuthRecordLocalOnly && \ |
| 184 | (rr)->resrec.RecordType & kDNSRecordTypeUniqueMask && \ |
| 185 | ((rr)->resrec.rrtype == kDNSType_A || (rr)->resrec.rrtype == kDNSType_AAAA || \ |
| 186 | (rr)->resrec.rrtype == kDNSType_CNAME || \ |
| 187 | (rr)->resrec.rrtype == kDNSType_PTR)) |
| 188 | |
| 189 | mDNSlocal void SetNextQueryStopTime(mDNS *const m, const DNSQuestion *const q) |
| 190 | { |
| 191 | mDNS_CheckLock(m); |
| 192 | |
| 193 | if (m->NextScheduledStopTime - q->StopTime > 0) |
| 194 | m->NextScheduledStopTime = q->StopTime; |
| 195 | } |
| 196 | |
| 197 | mDNSexport void SetNextQueryTime(mDNS *const m, const DNSQuestion *const q) |
| 198 | { |
| 199 | mDNS_CheckLock(m); |
| 200 | |
| 201 | if (ActiveQuestion(q)) |
| 202 | { |
| 203 | // Depending on whether this is a multicast or unicast question we want to set either: |
| 204 | // m->NextScheduledQuery = NextQSendTime(q) or |
| 205 | // m->NextuDNSEvent = NextQSendTime(q) |
| 206 | mDNSs32 *const timer = mDNSOpaque16IsZero(q->TargetQID) ? &m->NextScheduledQuery : &m->NextuDNSEvent; |
| 207 | if (*timer - NextQSendTime(q) > 0) |
| 208 | *timer = NextQSendTime(q); |
| 209 | } |
| 210 | } |
| 211 | |
| 212 | mDNSlocal void ReleaseAuthEntity(AuthHash *r, AuthEntity *e) |
| 213 | { |
| 214 | #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1 |
| 215 | unsigned int i; |
| 216 | for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF; |
| 217 | #endif |
| 218 | e->next = r->rrauth_free; |
| 219 | r->rrauth_free = e; |
| 220 | r->rrauth_totalused--; |
| 221 | } |
| 222 | |
| 223 | mDNSlocal void ReleaseAuthGroup(AuthHash *r, AuthGroup **cp) |
| 224 | { |
| 225 | AuthEntity *e = (AuthEntity *)(*cp); |
| 226 | LogMsg("ReleaseAuthGroup: Releasing AuthGroup %##s" , (*cp)->name->c); |
| 227 | if ((*cp)->rrauth_tail != &(*cp)->members) |
| 228 | LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrauth_tail != &(*cp)->members)" ); |
| 229 | if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name); |
| 230 | (*cp)->name = mDNSNULL; |
| 231 | *cp = (*cp)->next; // Cut record from list |
| 232 | ReleaseAuthEntity(r, e); |
| 233 | } |
| 234 | |
| 235 | mDNSlocal AuthEntity *GetAuthEntity(AuthHash *r, const AuthGroup *const PreserveAG) |
| 236 | { |
| 237 | AuthEntity *e = mDNSNULL; |
| 238 | |
| 239 | if (r->rrauth_lock) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!" ); return(mDNSNULL); } |
| 240 | r->rrauth_lock = 1; |
| 241 | |
| 242 | if (!r->rrauth_free) |
| 243 | { |
| 244 | // We allocate just one AuthEntity at a time because we need to be able |
| 245 | // free them all individually which normally happens when we parse /etc/hosts into |
| 246 | // AuthHash where we add the "new" entries and discard (free) the already added |
| 247 | // entries. If we allocate as chunks, we can't free them individually. |
| 248 | AuthEntity *storage = mDNSPlatformMemAllocate(sizeof(AuthEntity)); |
| 249 | storage->next = mDNSNULL; |
| 250 | r->rrauth_free = storage; |
| 251 | } |
| 252 | |
| 253 | // If we still have no free records, recycle all the records we can. |
| 254 | // Enumerating the entire auth is moderately expensive, so when we do it, we reclaim all the records we can in one pass. |
| 255 | if (!r->rrauth_free) |
| 256 | { |
| 257 | mDNSu32 oldtotalused = r->rrauth_totalused; |
| 258 | mDNSu32 slot; |
| 259 | for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) |
| 260 | { |
| 261 | AuthGroup **cp = &r->rrauth_hash[slot]; |
| 262 | while (*cp) |
| 263 | { |
| 264 | if ((*cp)->members || (*cp)==PreserveAG) cp=&(*cp)->next; |
| 265 | else ReleaseAuthGroup(r, cp); |
| 266 | } |
| 267 | } |
| 268 | LogInfo("GetAuthEntity: Recycled %d records to reduce auth cache from %d to %d" , |
| 269 | oldtotalused - r->rrauth_totalused, oldtotalused, r->rrauth_totalused); |
| 270 | } |
| 271 | |
| 272 | if (r->rrauth_free) // If there are records in the free list, take one |
| 273 | { |
| 274 | e = r->rrauth_free; |
| 275 | r->rrauth_free = e->next; |
| 276 | if (++r->rrauth_totalused >= r->rrauth_report) |
| 277 | { |
| 278 | LogInfo("RR Auth now using %ld objects" , r->rrauth_totalused); |
| 279 | if (r->rrauth_report < 100) r->rrauth_report += 10; |
| 280 | else if (r->rrauth_report < 1000) r->rrauth_report += 100; |
| 281 | else r->rrauth_report += 1000; |
| 282 | } |
| 283 | mDNSPlatformMemZero(e, sizeof(*e)); |
| 284 | } |
| 285 | |
| 286 | r->rrauth_lock = 0; |
| 287 | |
| 288 | return(e); |
| 289 | } |
| 290 | |
| 291 | mDNSexport AuthGroup *AuthGroupForName(AuthHash *r, const mDNSu32 namehash, const domainname *const name) |
| 292 | { |
| 293 | AuthGroup *ag; |
| 294 | const mDNSu32 slot = namehash % AUTH_HASH_SLOTS; |
| 295 | |
| 296 | for (ag = r->rrauth_hash[slot]; ag; ag=ag->next) |
| 297 | if (ag->namehash == namehash && SameDomainName(ag->name, name)) |
| 298 | break; |
| 299 | return(ag); |
| 300 | } |
| 301 | |
| 302 | mDNSexport AuthGroup *AuthGroupForRecord(AuthHash *r, const ResourceRecord *const rr) |
| 303 | { |
| 304 | return(AuthGroupForName(r, rr->namehash, rr->name)); |
| 305 | } |
| 306 | |
| 307 | mDNSlocal AuthGroup *GetAuthGroup(AuthHash *r, const ResourceRecord *const rr) |
| 308 | { |
| 309 | mDNSu16 namelen = DomainNameLength(rr->name); |
| 310 | AuthGroup *ag = (AuthGroup*)GetAuthEntity(r, mDNSNULL); |
| 311 | const mDNSu32 slot = rr->namehash % AUTH_HASH_SLOTS; |
| 312 | if (!ag) { LogMsg("GetAuthGroup: Failed to allocate memory for %##s" , rr->name->c); return(mDNSNULL); } |
| 313 | ag->next = r->rrauth_hash[slot]; |
| 314 | ag->namehash = rr->namehash; |
| 315 | ag->members = mDNSNULL; |
| 316 | ag->rrauth_tail = &ag->members; |
| 317 | ag->NewLocalOnlyRecords = mDNSNULL; |
| 318 | if (namelen > sizeof(ag->namestorage)) |
| 319 | ag->name = mDNSPlatformMemAllocate(namelen); |
| 320 | else |
| 321 | ag->name = (domainname*)ag->namestorage; |
| 322 | if (!ag->name) |
| 323 | { |
| 324 | LogMsg("GetAuthGroup: Failed to allocate name storage for %##s" , rr->name->c); |
| 325 | ReleaseAuthEntity(r, (AuthEntity*)ag); |
| 326 | return(mDNSNULL); |
| 327 | } |
| 328 | AssignDomainName(ag->name, rr->name); |
| 329 | |
| 330 | if (AuthGroupForRecord(r, rr)) LogMsg("GetAuthGroup: Already have AuthGroup for %##s" , rr->name->c); |
| 331 | r->rrauth_hash[slot] = ag; |
| 332 | if (AuthGroupForRecord(r, rr) != ag) LogMsg("GetAuthGroup: Not finding AuthGroup for %##s" , rr->name->c); |
| 333 | |
| 334 | return(ag); |
| 335 | } |
| 336 | |
| 337 | // Returns the AuthGroup in which the AuthRecord was inserted |
| 338 | mDNSexport AuthGroup *InsertAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr) |
| 339 | { |
| 340 | AuthGroup *ag; |
| 341 | |
| 342 | (void)m; |
| 343 | ag = AuthGroupForRecord(r, &rr->resrec); |
| 344 | if (!ag) ag = GetAuthGroup(r, &rr->resrec); // If we don't have a AuthGroup for this name, make one now |
| 345 | if (ag) |
| 346 | { |
| 347 | *(ag->rrauth_tail) = rr; // Append this record to tail of cache slot list |
| 348 | ag->rrauth_tail = &(rr->next); // Advance tail pointer |
| 349 | } |
| 350 | return ag; |
| 351 | } |
| 352 | |
| 353 | mDNSexport AuthGroup *RemoveAuthRecord(mDNS *const m, AuthHash *r, AuthRecord *rr) |
| 354 | { |
| 355 | AuthGroup *a; |
| 356 | AuthRecord **rp; |
| 357 | |
| 358 | a = AuthGroupForRecord(r, &rr->resrec); |
| 359 | if (!a) { LogMsg("RemoveAuthRecord: ERROR!! AuthGroup not found for %s" , ARDisplayString(m, rr)); return mDNSNULL; } |
| 360 | rp = &a->members; |
| 361 | while (*rp) |
| 362 | { |
| 363 | if (*rp != rr) |
| 364 | rp=&(*rp)->next; |
| 365 | else |
| 366 | { |
| 367 | // We don't break here, so that we can set the tail below without tracking "prev" pointers |
| 368 | |
| 369 | LogInfo("RemoveAuthRecord: removing auth record %s from table" , ARDisplayString(m, rr)); |
| 370 | *rp = (*rp)->next; // Cut record from list |
| 371 | } |
| 372 | } |
| 373 | // TBD: If there are no more members, release authgroup ? |
| 374 | a->rrauth_tail = rp; |
| 375 | return a; |
| 376 | } |
| 377 | |
| 378 | mDNSexport CacheGroup *CacheGroupForName(const mDNS *const m, const mDNSu32 namehash, const domainname *const name) |
| 379 | { |
| 380 | CacheGroup *cg; |
| 381 | mDNSu32 slot = HashSlotFromNameHash(namehash); |
| 382 | for (cg = m->rrcache_hash[slot]; cg; cg=cg->next) |
| 383 | if (cg->namehash == namehash && SameDomainName(cg->name, name)) |
| 384 | break; |
| 385 | return(cg); |
| 386 | } |
| 387 | |
| 388 | mDNSlocal CacheGroup *CacheGroupForRecord(const mDNS *const m, const ResourceRecord *const rr) |
| 389 | { |
| 390 | return(CacheGroupForName(m, rr->namehash, rr->name)); |
| 391 | } |
| 392 | |
| 393 | mDNSexport mDNSBool mDNS_AddressIsLocalSubnet(mDNS *const m, const mDNSInterfaceID InterfaceID, const mDNSAddr *addr) |
| 394 | { |
| 395 | NetworkInterfaceInfo *intf; |
| 396 | |
| 397 | if (addr->type == mDNSAddrType_IPv4) |
| 398 | { |
| 399 | // Normally we resist touching the NotAnInteger fields, but here we're doing tricky bitwise masking so we make an exception |
| 400 | if (mDNSv4AddressIsLinkLocal(&addr->ip.v4)) return(mDNStrue); |
| 401 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 402 | if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx) |
| 403 | if (((intf->ip.ip.v4.NotAnInteger ^ addr->ip.v4.NotAnInteger) & intf->mask.ip.v4.NotAnInteger) == 0) |
| 404 | return(mDNStrue); |
| 405 | } |
| 406 | |
| 407 | if (addr->type == mDNSAddrType_IPv6) |
| 408 | { |
| 409 | if (mDNSv6AddressIsLinkLocal(&addr->ip.v6)) return(mDNStrue); |
| 410 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 411 | if (intf->ip.type == addr->type && intf->InterfaceID == InterfaceID && intf->McastTxRx) |
| 412 | if ((((intf->ip.ip.v6.l[0] ^ addr->ip.v6.l[0]) & intf->mask.ip.v6.l[0]) == 0) && |
| 413 | (((intf->ip.ip.v6.l[1] ^ addr->ip.v6.l[1]) & intf->mask.ip.v6.l[1]) == 0) && |
| 414 | (((intf->ip.ip.v6.l[2] ^ addr->ip.v6.l[2]) & intf->mask.ip.v6.l[2]) == 0) && |
| 415 | (((intf->ip.ip.v6.l[3] ^ addr->ip.v6.l[3]) & intf->mask.ip.v6.l[3]) == 0)) |
| 416 | return(mDNStrue); |
| 417 | } |
| 418 | |
| 419 | return(mDNSfalse); |
| 420 | } |
| 421 | |
| 422 | mDNSlocal NetworkInterfaceInfo *FirstInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID) |
| 423 | { |
| 424 | NetworkInterfaceInfo *intf = m->HostInterfaces; |
| 425 | while (intf && intf->InterfaceID != InterfaceID) intf = intf->next; |
| 426 | return(intf); |
| 427 | } |
| 428 | |
| 429 | mDNSlocal NetworkInterfaceInfo *FirstIPv4LLInterfaceForID(mDNS *const m, const mDNSInterfaceID InterfaceID) |
| 430 | { |
| 431 | NetworkInterfaceInfo *intf; |
| 432 | |
| 433 | if (!InterfaceID) |
| 434 | return mDNSNULL; |
| 435 | |
| 436 | // Note: We don't check for InterfaceActive, as the active interface could be IPv6 and |
| 437 | // we still want to find the first IPv4 Link-Local interface |
| 438 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 439 | { |
| 440 | if (intf->InterfaceID == InterfaceID && |
| 441 | intf->ip.type == mDNSAddrType_IPv4 && mDNSv4AddressIsLinkLocal(&intf->ip.ip.v4)) |
| 442 | { |
| 443 | debugf("FirstIPv4LLInterfaceForID: found LL interface with address %.4a" , &intf->ip.ip.v4); |
| 444 | return intf; |
| 445 | } |
| 446 | } |
| 447 | return (mDNSNULL); |
| 448 | } |
| 449 | |
| 450 | mDNSexport char *InterfaceNameForID(mDNS *const m, const mDNSInterfaceID InterfaceID) |
| 451 | { |
| 452 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); |
| 453 | return(intf ? intf->ifname : mDNSNULL); |
| 454 | } |
| 455 | |
| 456 | // Caller should hold the lock |
| 457 | mDNSlocal void GenerateNegativeResponse(mDNS *const m, mDNSInterfaceID InterfaceID, QC_result qc) |
| 458 | { |
| 459 | DNSQuestion *q; |
| 460 | if (!m->CurrentQuestion) { LogMsg("GenerateNegativeResponse: ERROR!! CurrentQuestion not set" ); return; } |
| 461 | q = m->CurrentQuestion; |
| 462 | LogInfo("GenerateNegativeResponse: Generating negative response for question %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 463 | |
| 464 | MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, InterfaceID, mDNSNULL); |
| 465 | |
| 466 | // We need to force the response through in the following cases |
| 467 | // |
| 468 | // a) SuppressUnusable questions that are suppressed |
| 469 | // b) Append search domains and retry the question |
| 470 | // |
| 471 | // The question may not have set Intermediates in which case we don't deliver negative responses. So, to force |
| 472 | // through we use "QC_forceresponse". |
| 473 | AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, qc); |
| 474 | if (m->CurrentQuestion == q) { q->ThisQInterval = 0; } // Deactivate this question |
| 475 | // Don't touch the question after this |
| 476 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 477 | } |
| 478 | |
| 479 | mDNSexport void AnswerQuestionByFollowingCNAME(mDNS *const m, DNSQuestion *q, ResourceRecord *rr) |
| 480 | { |
| 481 | const mDNSBool selfref = SameDomainName(&q->qname, &rr->rdata->u.name); |
| 482 | if (q->CNAMEReferrals >= 10 || selfref) |
| 483 | { |
| 484 | LogMsg("AnswerQuestionByFollowingCNAME: %p %##s (%s) NOT following CNAME referral %d%s for %s" , |
| 485 | q, q->qname.c, DNSTypeName(q->qtype), q->CNAMEReferrals, selfref ? " (Self-Referential)" : "" , RRDisplayString(m, rr)); |
| 486 | } |
| 487 | else |
| 488 | { |
| 489 | const mDNSu32 c = q->CNAMEReferrals + 1; // Stash a copy of the new q->CNAMEReferrals value |
| 490 | UDPSocket *sock = q->LocalSocket; |
| 491 | mDNSOpaque16 id = q->TargetQID; |
| 492 | #if AWD_METRICS |
| 493 | uDNSMetrics metrics; |
| 494 | #endif |
| 495 | |
| 496 | q->LocalSocket = mDNSNULL; |
| 497 | |
| 498 | // The SameDomainName check above is to ignore bogus CNAME records that point right back at |
| 499 | // themselves. Without that check we can get into a case where we have two duplicate questions, |
| 500 | // A and B, and when we stop question A, UpdateQuestionDuplicates copies the value of CNAMEReferrals |
| 501 | // from A to B, and then A is re-appended to the end of the list as a duplicate of B (because |
| 502 | // the target name is still the same), and then when we stop question B, UpdateQuestionDuplicates |
| 503 | // copies the B's value of CNAMEReferrals back to A, and we end up not incrementing CNAMEReferrals |
| 504 | // for either of them. This is not a problem for CNAME loops of two or more records because in |
| 505 | // those cases the newly re-appended question A has a different target name and therefore cannot be |
| 506 | // a duplicate of any other question ('B') which was itself a duplicate of the previous question A. |
| 507 | |
| 508 | // Right now we just stop and re-use the existing query. If we really wanted to be 100% perfect, |
| 509 | // and track CNAMEs coming and going, we should really create a subordinate query here, |
| 510 | // which we would subsequently cancel and retract if the CNAME referral record were removed. |
| 511 | // In reality this is such a corner case we'll ignore it until someone actually needs it. |
| 512 | |
| 513 | LogInfo("AnswerQuestionByFollowingCNAME: %p %##s (%s) following CNAME referral %d for %s" , |
| 514 | q, q->qname.c, DNSTypeName(q->qtype), q->CNAMEReferrals, RRDisplayString(m, rr)); |
| 515 | |
| 516 | #if AWD_METRICS |
| 517 | if ((q->CNAMEReferrals == 0) && !q->metrics.originalQName) |
| 518 | { |
| 519 | domainname * qName; |
| 520 | mDNSu16 qNameLen; |
| 521 | |
| 522 | qNameLen = DomainNameLength(&q->qname); |
| 523 | if ((qNameLen > 0) && (qNameLen <= MAX_DOMAIN_NAME)) |
| 524 | { |
| 525 | qName = mDNSPlatformMemAllocate(qNameLen); |
| 526 | if (qName) |
| 527 | { |
| 528 | mDNSPlatformMemCopy(qName->c, q->qname.c, qNameLen); |
| 529 | q->metrics.originalQName = qName; |
| 530 | } |
| 531 | } |
| 532 | } |
| 533 | metrics = q->metrics; |
| 534 | mDNSPlatformMemZero(&q->metrics, sizeof(q->metrics)); |
| 535 | #endif |
| 536 | mDNS_StopQuery_internal(m, q); // Stop old query |
| 537 | AssignDomainName(&q->qname, &rr->rdata->u.name); // Update qname |
| 538 | q->qnamehash = DomainNameHashValue(&q->qname); // and namehash |
| 539 | // If a unicast query results in a CNAME that points to a .local, we need to re-try |
| 540 | // this as unicast. Setting the mDNSInterface_Unicast tells mDNS_StartQuery_internal |
| 541 | // to try this as unicast query even though it is a .local name |
| 542 | if (!mDNSOpaque16IsZero(q->TargetQID) && IsLocalDomain(&q->qname)) |
| 543 | { |
| 544 | LogInfo("AnswerQuestionByFollowingCNAME: Resolving a .local CNAME %p %##s (%s) Record %s" , |
| 545 | q, q->qname.c, DNSTypeName(q->qtype), RRDisplayString(m, rr)); |
| 546 | q->InterfaceID = mDNSInterface_Unicast; |
| 547 | } |
| 548 | mDNS_StartQuery_internal(m, q); // start new query |
| 549 | // Record how many times we've done this. We need to do this *after* mDNS_StartQuery_internal, |
| 550 | // because mDNS_StartQuery_internal re-initializes CNAMEReferrals to zero |
| 551 | q->CNAMEReferrals = c; |
| 552 | #if AWD_METRICS |
| 553 | q->metrics = metrics; |
| 554 | #endif |
| 555 | if (sock) |
| 556 | { |
| 557 | // If our new query is a duplicate, then it can't have a socket of its own, so we have to close the one we saved. |
| 558 | if (q->DuplicateOf) mDNSPlatformUDPClose(sock); |
| 559 | else |
| 560 | { |
| 561 | // Transplant the old socket into the new question, and copy the query ID across too. |
| 562 | // No need to close the old q->LocalSocket value because it won't have been created yet (they're made lazily on-demand). |
| 563 | q->LocalSocket = sock; |
| 564 | q->TargetQID = id; |
| 565 | } |
| 566 | } |
| 567 | } |
| 568 | } |
| 569 | |
| 570 | #ifdef USE_LIBIDN |
| 571 | |
| 572 | #include <unicode/uidna.h> |
| 573 | |
| 574 | // #define DEBUG_PUNYCODE 1 |
| 575 | |
| 576 | mDNSlocal mDNSu8 *PunycodeConvert(const mDNSu8 *const src, mDNSu8 *const dst, const mDNSu8 *const end) |
| 577 | { |
| 578 | UErrorCode errorCode = U_ZERO_ERROR; |
| 579 | UIDNAInfo info = UIDNA_INFO_INITIALIZER; |
| 580 | UIDNA *uts46 = uidna_openUTS46(UIDNA_USE_STD3_RULES|UIDNA_NONTRANSITIONAL_TO_UNICODE, &errorCode); |
| 581 | int32_t len = uidna_nameToASCII_UTF8(uts46, (const char *)src+1, src[0], (char *)dst+1, end-(dst+1), &info, &errorCode); |
| 582 | uidna_close(uts46); |
| 583 | #if DEBUG_PUNYCODE |
| 584 | if (errorCode) LogMsg("uidna_nameToASCII_UTF8(%##s) failed errorCode %d" , src, errorCode); |
| 585 | if (info.errors) LogMsg("uidna_nameToASCII_UTF8(%##s) failed info.errors 0x%08X" , src, info.errors); |
| 586 | if (len > MAX_DOMAIN_LABEL) LogMsg("uidna_nameToASCII_UTF8(%##s) result too long %d" , src, len); |
| 587 | #endif |
| 588 | if (errorCode || info.errors || len > MAX_DOMAIN_LABEL) return mDNSNULL; |
| 589 | *dst = len; |
| 590 | return(dst + 1 + len); |
| 591 | } |
| 592 | |
| 593 | mDNSlocal mDNSBool IsHighASCIILabel(const mDNSu8 *d) |
| 594 | { |
| 595 | int i; |
| 596 | for (i=1; i<=d[0]; i++) if (d[i] & 0x80) return mDNStrue; |
| 597 | return mDNSfalse; |
| 598 | } |
| 599 | |
| 600 | mDNSlocal const mDNSu8 *FindLastHighASCIILabel(const domainname *const d) |
| 601 | { |
| 602 | const mDNSu8 *ptr = d->c; |
| 603 | const mDNSu8 *ans = mDNSNULL; |
| 604 | while (ptr[0]) |
| 605 | { |
| 606 | const mDNSu8 *const next = ptr + 1 + ptr[0]; |
| 607 | if (ptr[0] > MAX_DOMAIN_LABEL || next >= d->c + MAX_DOMAIN_NAME) return mDNSNULL; |
| 608 | if (IsHighASCIILabel(ptr)) ans = ptr; |
| 609 | ptr = next; |
| 610 | } |
| 611 | return ans; |
| 612 | } |
| 613 | |
| 614 | mDNSlocal mDNSBool PerformNextPunycodeConversion(const DNSQuestion *const q, domainname *const newname) |
| 615 | { |
| 616 | const mDNSu8 *h = FindLastHighASCIILabel(&q->qname); |
| 617 | #if DEBUG_PUNYCODE |
| 618 | LogMsg("PerformNextPunycodeConversion: %##s (%s) Last High-ASCII Label %##s" , q->qname.c, DNSTypeName(q->qtype), h); |
| 619 | #endif |
| 620 | if (!h) return mDNSfalse; // There are no high-ascii labels to convert |
| 621 | |
| 622 | mDNSu8 *const dst = PunycodeConvert(h, newname->c + (h - q->qname.c), newname->c + MAX_DOMAIN_NAME); |
| 623 | if (!dst) |
| 624 | return mDNSfalse; // The label was not convertible to Punycode |
| 625 | else |
| 626 | { |
| 627 | // If Punycode conversion of final eligible label was successful, copy the rest of the domainname |
| 628 | const mDNSu8 *const src = h + 1 + h[0]; |
| 629 | const mDNSu8 remainder = DomainNameLength((domainname*)src); |
| 630 | if (dst + remainder > newname->c + MAX_DOMAIN_NAME) return mDNSfalse; // Name too long -- cannot be converted to Punycode |
| 631 | |
| 632 | mDNSPlatformMemCopy(newname->c, q->qname.c, h - q->qname.c); // Fill in the leading part |
| 633 | mDNSPlatformMemCopy(dst, src, remainder); // Fill in the trailing part |
| 634 | #if DEBUG_PUNYCODE |
| 635 | LogMsg("PerformNextPunycodeConversion: %##s converted to %##s" , q->qname.c, newname->c); |
| 636 | #endif |
| 637 | return mDNStrue; |
| 638 | } |
| 639 | } |
| 640 | |
| 641 | #endif // USE_LIBIDN |
| 642 | |
| 643 | // For a single given DNSQuestion pointed to by CurrentQuestion, deliver an add/remove result for the single given AuthRecord |
| 644 | // Note: All the callers should use the m->CurrentQuestion to see if the question is still valid or not |
| 645 | mDNSlocal void AnswerLocalQuestionWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) |
| 646 | { |
| 647 | DNSQuestion *q = m->CurrentQuestion; |
| 648 | mDNSBool followcname; |
| 649 | |
| 650 | if (!q) |
| 651 | { |
| 652 | LogMsg("AnswerLocalQuestionWithLocalAuthRecord: ERROR!! CurrentQuestion NULL while answering with %s" , ARDisplayString(m, rr)); |
| 653 | return; |
| 654 | } |
| 655 | |
| 656 | followcname = FollowCNAME(q, &rr->resrec, AddRecord); |
| 657 | |
| 658 | // We should not be delivering results for record types Unregistered, Deregistering, and (unverified) Unique |
| 659 | if (!(rr->resrec.RecordType & kDNSRecordTypeActiveMask)) |
| 660 | { |
| 661 | LogMsg("AnswerLocalQuestionWithLocalAuthRecord: *NOT* delivering %s event for local record type %X %s" , |
| 662 | AddRecord ? "Add" : "Rmv" , rr->resrec.RecordType, ARDisplayString(m, rr)); |
| 663 | return; |
| 664 | } |
| 665 | |
| 666 | // Indicate that we've given at least one positive answer for this record, so we should be prepared to send a goodbye for it |
| 667 | if (AddRecord) rr->AnsweredLocalQ = mDNStrue; |
| 668 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 669 | if (q->QuestionCallback && !q->NoAnswer) |
| 670 | { |
| 671 | q->CurrentAnswers += AddRecord ? 1 : -1; |
| 672 | if (UniqueLocalOnlyRecord(rr)) |
| 673 | { |
| 674 | if (!followcname || q->ReturnIntermed) |
| 675 | { |
| 676 | // Don't send this packet on the wire as we answered from /etc/hosts |
| 677 | q->ThisQInterval = 0; |
| 678 | q->LOAddressAnswers += AddRecord ? 1 : -1; |
| 679 | q->QuestionCallback(m, q, &rr->resrec, AddRecord); |
| 680 | } |
| 681 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 682 | // The callback above could have caused the question to stop. Detect that |
| 683 | // using m->CurrentQuestion |
| 684 | if (followcname && m->CurrentQuestion == q) |
| 685 | AnswerQuestionByFollowingCNAME(m, q, &rr->resrec); |
| 686 | return; |
| 687 | } |
| 688 | else |
| 689 | { |
| 690 | q->QuestionCallback(m, q, &rr->resrec, AddRecord); |
| 691 | } |
| 692 | } |
| 693 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 694 | } |
| 695 | |
| 696 | mDNSlocal void AnswerInterfaceAnyQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) |
| 697 | { |
| 698 | if (m->CurrentQuestion) |
| 699 | LogMsg("AnswerInterfaceAnyQuestionsWithLocalAuthRecord: ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 700 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 701 | m->CurrentQuestion = m->Questions; |
| 702 | while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) |
| 703 | { |
| 704 | mDNSBool answered; |
| 705 | DNSQuestion *q = m->CurrentQuestion; |
| 706 | if (RRAny(rr)) |
| 707 | answered = ResourceRecordAnswersQuestion(&rr->resrec, q); |
| 708 | else |
| 709 | answered = LocalOnlyRecordAnswersQuestion(rr, q); |
| 710 | if (answered) |
| 711 | AnswerLocalQuestionWithLocalAuthRecord(m, rr, AddRecord); // MUST NOT dereference q again |
| 712 | if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now |
| 713 | m->CurrentQuestion = q->next; |
| 714 | } |
| 715 | m->CurrentQuestion = mDNSNULL; |
| 716 | } |
| 717 | |
| 718 | // When a new local AuthRecord is created or deleted, AnswerAllLocalQuestionsWithLocalAuthRecord() |
| 719 | // delivers the appropriate add/remove events to listening questions: |
| 720 | // 1. It runs though all our LocalOnlyQuestions delivering answers as appropriate, |
| 721 | // stopping if it reaches a NewLocalOnlyQuestion -- brand-new questions are handled by AnswerNewLocalOnlyQuestion(). |
| 722 | // 2. If the AuthRecord is marked mDNSInterface_LocalOnly or mDNSInterface_P2P, then it also runs though |
| 723 | // our main question list, delivering answers to mDNSInterface_Any questions as appropriate, |
| 724 | // stopping if it reaches a NewQuestion -- brand-new questions are handled by AnswerNewQuestion(). |
| 725 | // |
| 726 | // AnswerAllLocalQuestionsWithLocalAuthRecord is used by the m->NewLocalRecords loop in mDNS_Execute(), |
| 727 | // and by mDNS_Deregister_internal() |
| 728 | |
| 729 | mDNSlocal void AnswerAllLocalQuestionsWithLocalAuthRecord(mDNS *const m, AuthRecord *rr, QC_result AddRecord) |
| 730 | { |
| 731 | if (m->CurrentQuestion) |
| 732 | LogMsg("AnswerAllLocalQuestionsWithLocalAuthRecord ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 733 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 734 | |
| 735 | m->CurrentQuestion = m->LocalOnlyQuestions; |
| 736 | while (m->CurrentQuestion && m->CurrentQuestion != m->NewLocalOnlyQuestions) |
| 737 | { |
| 738 | mDNSBool answered; |
| 739 | DNSQuestion *q = m->CurrentQuestion; |
| 740 | // We are called with both LocalOnly/P2P record or a regular AuthRecord |
| 741 | if (RRAny(rr)) |
| 742 | answered = ResourceRecordAnswersQuestion(&rr->resrec, q); |
| 743 | else |
| 744 | answered = LocalOnlyRecordAnswersQuestion(rr, q); |
| 745 | if (answered) |
| 746 | AnswerLocalQuestionWithLocalAuthRecord(m, rr, AddRecord); // MUST NOT dereference q again |
| 747 | if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now |
| 748 | m->CurrentQuestion = q->next; |
| 749 | } |
| 750 | |
| 751 | m->CurrentQuestion = mDNSNULL; |
| 752 | |
| 753 | // If this AuthRecord is marked LocalOnly or P2P, then we want to deliver it to all local 'mDNSInterface_Any' questions |
| 754 | if (rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P) |
| 755 | AnswerInterfaceAnyQuestionsWithLocalAuthRecord(m, rr, AddRecord); |
| 756 | |
| 757 | } |
| 758 | |
| 759 | // *************************************************************************** |
| 760 | #if COMPILER_LIKES_PRAGMA_MARK |
| 761 | #pragma mark - |
| 762 | #pragma mark - Resource Record Utility Functions |
| 763 | #endif |
| 764 | |
| 765 | #define RRTypeIsAddressType(T) ((T) == kDNSType_A || (T) == kDNSType_AAAA) |
| 766 | |
| 767 | #define ResourceRecordIsValidAnswer(RR) ( ((RR)->resrec.RecordType & kDNSRecordTypeActiveMask) && \ |
| 768 | ((RR)->Additional1 == mDNSNULL || ((RR)->Additional1->resrec.RecordType & kDNSRecordTypeActiveMask)) && \ |
| 769 | ((RR)->Additional2 == mDNSNULL || ((RR)->Additional2->resrec.RecordType & kDNSRecordTypeActiveMask)) && \ |
| 770 | ((RR)->DependentOn == mDNSNULL || ((RR)->DependentOn->resrec.RecordType & kDNSRecordTypeActiveMask)) ) |
| 771 | |
| 772 | #define ResourceRecordIsValidInterfaceAnswer(RR, INTID) \ |
| 773 | (ResourceRecordIsValidAnswer(RR) && \ |
| 774 | ((RR)->resrec.InterfaceID == mDNSInterface_Any || (RR)->resrec.InterfaceID == (INTID))) |
| 775 | |
| 776 | #define DefaultProbeCountForTypeUnique ((mDNSu8)3) |
| 777 | #define DefaultProbeCountForRecordType(X) ((X) == kDNSRecordTypeUnique ? DefaultProbeCountForTypeUnique : (mDNSu8)0) |
| 778 | |
| 779 | // See RFC 6762: "8.3 Announcing" |
| 780 | // "The Multicast DNS responder MUST send at least two unsolicited responses, one second apart." |
| 781 | // Send 4, which is really 8 since we send on both IPv4 and IPv6. |
| 782 | #define InitialAnnounceCount ((mDNSu8)4) |
| 783 | |
| 784 | // For goodbye packets we set the count to 3, and for wakeups we set it to 18 |
| 785 | // (which will be up to 15 wakeup attempts over the course of 30 seconds, |
| 786 | // and then if the machine fails to wake, 3 goodbye packets). |
| 787 | #define GoodbyeCount ((mDNSu8)3) |
| 788 | #define WakeupCount ((mDNSu8)18) |
| 789 | #define MAX_PROBE_RESTARTS ((mDNSu8)20) |
| 790 | |
| 791 | // Number of wakeups we send if WakeOnResolve is set in the question |
| 792 | #define InitialWakeOnResolveCount ((mDNSu8)3) |
| 793 | |
| 794 | // Note that the announce intervals use exponential backoff, doubling each time. The probe intervals do not. |
| 795 | // This means that because the announce interval is doubled after sending the first packet, the first |
| 796 | // observed on-the-wire inter-packet interval between announcements is actually one second. |
| 797 | // The half-second value here may be thought of as a conceptual (non-existent) half-second delay *before* the first packet is sent. |
| 798 | #define DefaultProbeIntervalForTypeUnique (mDNSPlatformOneSecond/4) |
| 799 | #define DefaultAnnounceIntervalForTypeShared (mDNSPlatformOneSecond/2) |
| 800 | #define DefaultAnnounceIntervalForTypeUnique (mDNSPlatformOneSecond/2) |
| 801 | |
| 802 | #define DefaultAPIntervalForRecordType(X) ((X) &kDNSRecordTypeActiveSharedMask ? DefaultAnnounceIntervalForTypeShared : \ |
| 803 | (X) &kDNSRecordTypeUnique ? DefaultProbeIntervalForTypeUnique : \ |
| 804 | (X) &kDNSRecordTypeActiveUniqueMask ? DefaultAnnounceIntervalForTypeUnique : 0) |
| 805 | |
| 806 | #define TimeToAnnounceThisRecord(RR,time) ((RR)->AnnounceCount && (time) - ((RR)->LastAPTime + (RR)->ThisAPInterval) >= 0) |
| 807 | #define TicksTTL(RR) ((mDNSs32)(RR)->resrec.rroriginalttl * mDNSPlatformOneSecond) |
| 808 | #define RRExpireTime(RR) ((RR)->TimeRcvd + TicksTTL(RR)) |
| 809 | |
| 810 | // Adjustment factor to avoid race condition (used for unicast cache entries) : |
| 811 | // Suppose real record has TTL of 3600, and our local caching server has held it for 3500 seconds, so it returns an aged TTL of 100. |
| 812 | // If we do our normal refresh at 80% of the TTL, our local caching server will return 20 seconds, so we'll do another |
| 813 | // 80% refresh after 16 seconds, and then the server will return 4 seconds, and so on, in the fashion of Zeno's paradox. |
| 814 | // To avoid this, we extend the record's effective TTL to give it a little extra grace period. |
| 815 | // We adjust the 100 second TTL to 127. This means that when we do our 80% query at 102 seconds, |
| 816 | // the cached copy at our local caching server will already have expired, so the server will be forced |
| 817 | // to fetch a fresh copy from the authoritative server, and then return a fresh record with the full TTL of 3600 seconds. |
| 818 | |
| 819 | #define RRAdjustTTL(ttl) ((ttl) + ((ttl)/4) + 2) |
| 820 | #define RRUnadjustedTTL(ttl) ((((ttl) - 2) * 4) / 5) |
| 821 | |
| 822 | #define MaxUnansweredQueries 4 |
| 823 | |
| 824 | // SameResourceRecordSignature returns true if two resources records have the same name, type, and class, and may be sent |
| 825 | // (or were received) on the same interface (i.e. if *both* records specify an interface, then it has to match). |
| 826 | // TTL and rdata may differ. |
| 827 | // This is used for cache flush management: |
| 828 | // When sending a unique record, all other records matching "SameResourceRecordSignature" must also be sent |
| 829 | // When receiving a unique record, all old cache records matching "SameResourceRecordSignature" are flushed |
| 830 | |
| 831 | // SameResourceRecordNameClassInterface is functionally the same as SameResourceRecordSignature, except rrtype does not have to match |
| 832 | |
| 833 | #define SameResourceRecordSignature(A,B) (A)->resrec.rrtype == (B)->resrec.rrtype && SameResourceRecordNameClassInterface((A),(B)) |
| 834 | |
| 835 | mDNSlocal mDNSBool SameResourceRecordNameClassInterface(const AuthRecord *const r1, const AuthRecord *const r2) |
| 836 | { |
| 837 | if (!r1) { LogMsg("SameResourceRecordSignature ERROR: r1 is NULL" ); return(mDNSfalse); } |
| 838 | if (!r2) { LogMsg("SameResourceRecordSignature ERROR: r2 is NULL" ); return(mDNSfalse); } |
| 839 | if (r1->resrec.InterfaceID && |
| 840 | r2->resrec.InterfaceID && |
| 841 | r1->resrec.InterfaceID != r2->resrec.InterfaceID) return(mDNSfalse); |
| 842 | return (mDNSBool)( |
| 843 | r1->resrec.rrclass == r2->resrec.rrclass && |
| 844 | r1->resrec.namehash == r2->resrec.namehash && |
| 845 | SameDomainName(r1->resrec.name, r2->resrec.name)); |
| 846 | } |
| 847 | |
| 848 | // PacketRRMatchesSignature behaves as SameResourceRecordSignature, except that types may differ if our |
| 849 | // authoratative record is unique (as opposed to shared). For unique records, we are supposed to have |
| 850 | // complete ownership of *all* types for this name, so *any* record type with the same name is a conflict. |
| 851 | // In addition, when probing we send our questions with the wildcard type kDNSQType_ANY, |
| 852 | // so a response of any type should match, even if it is not actually the type the client plans to use. |
| 853 | |
| 854 | // For now, to make it easier to avoid false conflicts, we treat SPS Proxy records like shared records, |
| 855 | // and require the rrtypes to match for the rdata to be considered potentially conflicting |
| 856 | mDNSlocal mDNSBool PacketRRMatchesSignature(const CacheRecord *const pktrr, const AuthRecord *const authrr) |
| 857 | { |
| 858 | if (!pktrr) { LogMsg("PacketRRMatchesSignature ERROR: pktrr is NULL" ); return(mDNSfalse); } |
| 859 | if (!authrr) { LogMsg("PacketRRMatchesSignature ERROR: authrr is NULL" ); return(mDNSfalse); } |
| 860 | if (pktrr->resrec.InterfaceID && |
| 861 | authrr->resrec.InterfaceID && |
| 862 | pktrr->resrec.InterfaceID != authrr->resrec.InterfaceID) return(mDNSfalse); |
| 863 | if (!(authrr->resrec.RecordType & kDNSRecordTypeUniqueMask) || authrr->WakeUp.HMAC.l[0]) |
| 864 | if (pktrr->resrec.rrtype != authrr->resrec.rrtype) return(mDNSfalse); |
| 865 | if ((authrr->resrec.InterfaceID == mDNSInterface_Any) && |
| 866 | !mDNSPlatformValidRecordForInterface(authrr, pktrr->resrec.InterfaceID)) return(mDNSfalse); |
| 867 | return (mDNSBool)( |
| 868 | pktrr->resrec.rrclass == authrr->resrec.rrclass && |
| 869 | pktrr->resrec.namehash == authrr->resrec.namehash && |
| 870 | SameDomainName(pktrr->resrec.name, authrr->resrec.name)); |
| 871 | } |
| 872 | |
| 873 | // CacheRecord *ka is the CacheRecord from the known answer list in the query. |
| 874 | // This is the information that the requester believes to be correct. |
| 875 | // AuthRecord *rr is the answer we are proposing to give, if not suppressed. |
| 876 | // This is the information that we believe to be correct. |
| 877 | // We've already determined that we plan to give this answer on this interface |
| 878 | // (either the record is non-specific, or it is specific to this interface) |
| 879 | // so now we just need to check the name, type, class, rdata and TTL. |
| 880 | mDNSlocal mDNSBool ShouldSuppressKnownAnswer(const CacheRecord *const ka, const AuthRecord *const rr) |
| 881 | { |
| 882 | // If RR signature is different, or data is different, then don't suppress our answer |
| 883 | if (!IdenticalResourceRecord(&ka->resrec, &rr->resrec)) return(mDNSfalse); |
| 884 | |
| 885 | // If the requester's indicated TTL is less than half the real TTL, |
| 886 | // we need to give our answer before the requester's copy expires. |
| 887 | // If the requester's indicated TTL is at least half the real TTL, |
| 888 | // then we can suppress our answer this time. |
| 889 | // If the requester's indicated TTL is greater than the TTL we believe, |
| 890 | // then that's okay, and we don't need to do anything about it. |
| 891 | // (If two responders on the network are offering the same information, |
| 892 | // that's okay, and if they are offering the information with different TTLs, |
| 893 | // the one offering the lower TTL should defer to the one offering the higher TTL.) |
| 894 | return (mDNSBool)(ka->resrec.rroriginalttl >= rr->resrec.rroriginalttl / 2); |
| 895 | } |
| 896 | |
| 897 | mDNSlocal void SetNextAnnounceProbeTime(mDNS *const m, const AuthRecord *const rr) |
| 898 | { |
| 899 | if (rr->resrec.RecordType == kDNSRecordTypeUnique) |
| 900 | { |
| 901 | if ((rr->LastAPTime + rr->ThisAPInterval) - m->timenow > mDNSPlatformOneSecond * 10) |
| 902 | { |
| 903 | LogMsg("SetNextAnnounceProbeTime: ProbeCount %d Next in %d %s" , rr->ProbeCount, (rr->LastAPTime + rr->ThisAPInterval) - m->timenow, ARDisplayString(m, rr)); |
| 904 | LogMsg("SetNextAnnounceProbeTime: m->SuppressProbes %d m->timenow %d diff %d" , m->SuppressProbes, m->timenow, m->SuppressProbes - m->timenow); |
| 905 | } |
| 906 | if (m->NextScheduledProbe - (rr->LastAPTime + rr->ThisAPInterval) >= 0) |
| 907 | m->NextScheduledProbe = (rr->LastAPTime + rr->ThisAPInterval); |
| 908 | // Some defensive code: |
| 909 | // If (rr->LastAPTime + rr->ThisAPInterval) happens to be far in the past, we don't want to allow |
| 910 | // NextScheduledProbe to be set excessively in the past, because that can cause bad things to happen. |
| 911 | // See: <rdar://problem/7795434> mDNS: Sometimes advertising stops working and record interval is set to zero |
| 912 | if (m->NextScheduledProbe - m->timenow < 0) |
| 913 | m->NextScheduledProbe = m->timenow; |
| 914 | } |
| 915 | else if (rr->AnnounceCount && (ResourceRecordIsValidAnswer(rr) || rr->resrec.RecordType == kDNSRecordTypeDeregistering)) |
| 916 | { |
| 917 | if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0) |
| 918 | m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval); |
| 919 | } |
| 920 | } |
| 921 | |
| 922 | mDNSlocal void InitializeLastAPTime(mDNS *const m, AuthRecord *const rr) |
| 923 | { |
| 924 | // For reverse-mapping Sleep Proxy PTR records, probe interval is one second |
| 925 | rr->ThisAPInterval = rr->AddressProxy.type ? mDNSPlatformOneSecond : DefaultAPIntervalForRecordType(rr->resrec.RecordType); |
| 926 | |
| 927 | // * If this is a record type that's going to probe, then we use the m->SuppressProbes time. |
| 928 | // * Otherwise, if it's not going to probe, but m->SuppressProbes is set because we have other |
| 929 | // records that are going to probe, then we delay its first announcement so that it will |
| 930 | // go out synchronized with the first announcement for the other records that *are* probing. |
| 931 | // This is a minor performance tweak that helps keep groups of related records synchronized together. |
| 932 | // The addition of "interval / 2" is to make sure that, in the event that any of the probes are |
| 933 | // delayed by a few milliseconds, this announcement does not inadvertently go out *before* the probing is complete. |
| 934 | // When the probing is complete and those records begin to announce, these records will also be picked up and accelerated, |
| 935 | // because they will meet the criterion of being at least half-way to their scheduled announcement time. |
| 936 | // * If it's not going to probe and m->SuppressProbes is not already set then we should announce immediately. |
| 937 | |
| 938 | if (rr->ProbeCount) |
| 939 | { |
| 940 | // If we have no probe suppression time set, or it is in the past, set it now |
| 941 | if (m->SuppressProbes == 0 || m->SuppressProbes - m->timenow < 0) |
| 942 | { |
| 943 | // To allow us to aggregate probes when a group of services are registered together, |
| 944 | // the first probe is delayed by a random delay in the range 1/8 to 1/4 second. |
| 945 | // This means the common-case behaviour is: |
| 946 | // randomized wait; probe |
| 947 | // 1/4 second wait; probe |
| 948 | // 1/4 second wait; probe |
| 949 | // 1/4 second wait; announce (i.e. service is normally announced 7/8 to 1 second after being registered) |
| 950 | m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2)); |
| 951 | |
| 952 | // If we already have a *probe* scheduled to go out sooner, then use that time to get better aggregation |
| 953 | if (m->SuppressProbes - m->NextScheduledProbe >= 0) |
| 954 | m->SuppressProbes = NonZeroTime(m->NextScheduledProbe); |
| 955 | if (m->SuppressProbes - m->timenow < 0) // Make sure we don't set m->SuppressProbes excessively in the past |
| 956 | m->SuppressProbes = m->timenow; |
| 957 | |
| 958 | // If we already have a *query* scheduled to go out sooner, then use that time to get better aggregation |
| 959 | if (m->SuppressProbes - m->NextScheduledQuery >= 0) |
| 960 | m->SuppressProbes = NonZeroTime(m->NextScheduledQuery); |
| 961 | if (m->SuppressProbes - m->timenow < 0) // Make sure we don't set m->SuppressProbes excessively in the past |
| 962 | m->SuppressProbes = m->timenow; |
| 963 | |
| 964 | // except... don't expect to be able to send before the m->SuppressSending timer fires |
| 965 | if (m->SuppressSending && m->SuppressProbes - m->SuppressSending < 0) |
| 966 | m->SuppressProbes = NonZeroTime(m->SuppressSending); |
| 967 | |
| 968 | if (m->SuppressProbes - m->timenow > mDNSPlatformOneSecond * 8) |
| 969 | { |
| 970 | LogMsg("InitializeLastAPTime ERROR m->SuppressProbes %d m->NextScheduledProbe %d m->NextScheduledQuery %d m->SuppressSending %d %d" , |
| 971 | m->SuppressProbes - m->timenow, |
| 972 | m->NextScheduledProbe - m->timenow, |
| 973 | m->NextScheduledQuery - m->timenow, |
| 974 | m->SuppressSending, |
| 975 | m->SuppressSending - m->timenow); |
| 976 | m->SuppressProbes = NonZeroTime(m->timenow + DefaultProbeIntervalForTypeUnique/2 + mDNSRandom(DefaultProbeIntervalForTypeUnique/2)); |
| 977 | } |
| 978 | } |
| 979 | rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval; |
| 980 | } |
| 981 | // Skip kDNSRecordTypeKnownUnique and kDNSRecordTypeShared records here and set their LastAPTime in the "else" block below so |
| 982 | // that they get announced immediately, otherwise, their announcement would be delayed until the based on the SuppressProbes value. |
| 983 | else if ((rr->resrec.RecordType != kDNSRecordTypeKnownUnique) && (rr->resrec.RecordType != kDNSRecordTypeShared) && m->SuppressProbes && (m->SuppressProbes - m->timenow >= 0)) |
| 984 | rr->LastAPTime = m->SuppressProbes - rr->ThisAPInterval + DefaultProbeIntervalForTypeUnique * DefaultProbeCountForTypeUnique + rr->ThisAPInterval / 2; |
| 985 | else |
| 986 | rr->LastAPTime = m->timenow - rr->ThisAPInterval; |
| 987 | |
| 988 | // For reverse-mapping Sleep Proxy PTR records we don't want to start probing instantly -- we |
| 989 | // wait one second to give the client a chance to go to sleep, and then start our ARP/NDP probing. |
| 990 | // After three probes one second apart with no answer, we conclude the client is now sleeping |
| 991 | // and we can begin broadcasting our announcements to take over ownership of that IP address. |
| 992 | // If we don't wait for the client to go to sleep, then when the client sees our ARP Announcements there's a risk |
| 993 | // (depending on the OS and networking stack it's using) that it might interpret it as a conflict and change its IP address. |
| 994 | if (rr->AddressProxy.type) |
| 995 | rr->LastAPTime = m->timenow; |
| 996 | |
| 997 | // Set LastMCTime to now, to inhibit multicast responses |
| 998 | // (no need to send additional multicast responses when we're announcing anyway) |
| 999 | rr->LastMCTime = m->timenow; |
| 1000 | rr->LastMCInterface = mDNSInterfaceMark; |
| 1001 | |
| 1002 | SetNextAnnounceProbeTime(m, rr); |
| 1003 | } |
| 1004 | |
| 1005 | mDNSlocal const domainname *SetUnicastTargetToHostName(mDNS *const m, AuthRecord *rr) |
| 1006 | { |
| 1007 | const domainname *target; |
| 1008 | if (rr->AutoTarget) |
| 1009 | { |
| 1010 | // For autotunnel services pointing at our IPv6 ULA we don't need or want a NAT mapping, but for all other |
| 1011 | // advertised services referencing our uDNS hostname, we want NAT mappings automatically created as appropriate, |
| 1012 | // with the port number in our advertised SRV record automatically tracking the external mapped port. |
| 1013 | DomainAuthInfo *AuthInfo = GetAuthInfoForName_internal(m, rr->resrec.name); |
| 1014 | if (!AuthInfo || !AuthInfo->AutoTunnel) rr->AutoTarget = Target_AutoHostAndNATMAP; |
| 1015 | } |
| 1016 | |
| 1017 | target = GetServiceTarget(m, rr); |
| 1018 | if (!target || target->c[0] == 0) |
| 1019 | { |
| 1020 | // defer registration until we've got a target |
| 1021 | LogInfo("SetUnicastTargetToHostName No target for %s" , ARDisplayString(m, rr)); |
| 1022 | rr->state = regState_NoTarget; |
| 1023 | return mDNSNULL; |
| 1024 | } |
| 1025 | else |
| 1026 | { |
| 1027 | LogInfo("SetUnicastTargetToHostName target %##s for resource record %s" , target->c, ARDisplayString(m,rr)); |
| 1028 | return target; |
| 1029 | } |
| 1030 | } |
| 1031 | |
| 1032 | // Right now this only applies to mDNS (.local) services where the target host is always m->MulticastHostname |
| 1033 | // Eventually we should unify this with GetServiceTarget() in uDNS.c |
| 1034 | mDNSlocal void SetTargetToHostName(mDNS *const m, AuthRecord *const rr) |
| 1035 | { |
| 1036 | domainname *const target = GetRRDomainNameTarget(&rr->resrec); |
| 1037 | const domainname *newname = &m->MulticastHostname; |
| 1038 | |
| 1039 | if (!target) LogInfo("SetTargetToHostName: Don't know how to set the target of rrtype %s" , DNSTypeName(rr->resrec.rrtype)); |
| 1040 | |
| 1041 | if (!(rr->ForceMCast || rr->ARType == AuthRecordLocalOnly || rr->ARType == AuthRecordP2P || IsLocalDomain(&rr->namestorage))) |
| 1042 | { |
| 1043 | const domainname *const n = SetUnicastTargetToHostName(m, rr); |
| 1044 | if (n) newname = n; |
| 1045 | else { if (target) target->c[0] = 0; SetNewRData(&rr->resrec, mDNSNULL, 0); return; } |
| 1046 | } |
| 1047 | |
| 1048 | if (target && SameDomainName(target, newname)) |
| 1049 | debugf("SetTargetToHostName: Target of %##s is already %##s" , rr->resrec.name->c, target->c); |
| 1050 | |
| 1051 | if (target && !SameDomainName(target, newname)) |
| 1052 | { |
| 1053 | AssignDomainName(target, newname); |
| 1054 | SetNewRData(&rr->resrec, mDNSNULL, 0); // Update rdlength, rdestimate, rdatahash |
| 1055 | |
| 1056 | // If we're in the middle of probing this record, we need to start again, |
| 1057 | // because changing its rdata may change the outcome of the tie-breaker. |
| 1058 | // (If the record type is kDNSRecordTypeUnique (unconfirmed unique) then DefaultProbeCountForRecordType is non-zero.) |
| 1059 | rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); |
| 1060 | |
| 1061 | // If we've announced this record, we really should send a goodbye packet for the old rdata before |
| 1062 | // changing to the new rdata. However, in practice, we only do SetTargetToHostName for unique records, |
| 1063 | // so when we announce them we'll set the kDNSClass_UniqueRRSet and clear any stale data that way. |
| 1064 | if (rr->RequireGoodbye && rr->resrec.RecordType == kDNSRecordTypeShared) |
| 1065 | debugf("Have announced shared record %##s (%s) at least once: should have sent a goodbye packet before updating" , |
| 1066 | rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1067 | |
| 1068 | rr->AnnounceCount = InitialAnnounceCount; |
| 1069 | rr->RequireGoodbye = mDNSfalse; |
| 1070 | rr->ProbeRestartCount = 0; |
| 1071 | InitializeLastAPTime(m, rr); |
| 1072 | } |
| 1073 | } |
| 1074 | |
| 1075 | mDNSlocal void AcknowledgeRecord(mDNS *const m, AuthRecord *const rr) |
| 1076 | { |
| 1077 | if (rr->RecordCallback) |
| 1078 | { |
| 1079 | // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function |
| 1080 | // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc. |
| 1081 | rr->Acknowledged = mDNStrue; |
| 1082 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 1083 | rr->RecordCallback(m, rr, mStatus_NoError); |
| 1084 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 1085 | } |
| 1086 | } |
| 1087 | |
| 1088 | mDNSexport void ActivateUnicastRegistration(mDNS *const m, AuthRecord *const rr) |
| 1089 | { |
| 1090 | // Make sure that we don't activate the SRV record and associated service records, if it is in |
| 1091 | // NoTarget state. First time when a service is being instantiated, SRV record may be in NoTarget state. |
| 1092 | // We should not activate any of the other reords (PTR, TXT) that are part of the service. When |
| 1093 | // the target becomes available, the records will be reregistered. |
| 1094 | if (rr->resrec.rrtype != kDNSType_SRV) |
| 1095 | { |
| 1096 | AuthRecord *srvRR = mDNSNULL; |
| 1097 | if (rr->resrec.rrtype == kDNSType_PTR) |
| 1098 | srvRR = rr->Additional1; |
| 1099 | else if (rr->resrec.rrtype == kDNSType_TXT) |
| 1100 | srvRR = rr->DependentOn; |
| 1101 | if (srvRR) |
| 1102 | { |
| 1103 | if (srvRR->resrec.rrtype != kDNSType_SRV) |
| 1104 | { |
| 1105 | LogMsg("ActivateUnicastRegistration: ERROR!! Resource record %s wrong, expecting SRV type" , ARDisplayString(m, srvRR)); |
| 1106 | } |
| 1107 | else |
| 1108 | { |
| 1109 | LogInfo("ActivateUnicastRegistration: Found Service Record %s in state %d for %##s (%s)" , |
| 1110 | ARDisplayString(m, srvRR), srvRR->state, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1111 | rr->state = srvRR->state; |
| 1112 | } |
| 1113 | } |
| 1114 | } |
| 1115 | |
| 1116 | if (rr->state == regState_NoTarget) |
| 1117 | { |
| 1118 | LogInfo("ActivateUnicastRegistration record %s in regState_NoTarget, not activating" , ARDisplayString(m, rr)); |
| 1119 | return; |
| 1120 | } |
| 1121 | // When we wake up from sleep, we call ActivateUnicastRegistration. It is possible that just before we went to sleep, |
| 1122 | // the service/record was being deregistered. In that case, we should not try to register again. For the cases where |
| 1123 | // the records are deregistered due to e.g., no target for the SRV record, we would have returned from above if it |
| 1124 | // was already in NoTarget state. If it was in the process of deregistration but did not complete fully before we went |
| 1125 | // to sleep, then it is okay to start in Pending state as we will go back to NoTarget state if we don't have a target. |
| 1126 | if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) |
| 1127 | { |
| 1128 | LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to DeregPending" , ARDisplayString(m, rr), rr->state); |
| 1129 | rr->state = regState_DeregPending; |
| 1130 | } |
| 1131 | else |
| 1132 | { |
| 1133 | LogInfo("ActivateUnicastRegistration: Resource record %s, current state %d, moving to Pending" , ARDisplayString(m, rr), rr->state); |
| 1134 | rr->state = regState_Pending; |
| 1135 | } |
| 1136 | rr->ProbeCount = 0; |
| 1137 | rr->ProbeRestartCount = 0; |
| 1138 | rr->AnnounceCount = 0; |
| 1139 | rr->ThisAPInterval = INIT_RECORD_REG_INTERVAL; |
| 1140 | rr->LastAPTime = m->timenow - rr->ThisAPInterval; |
| 1141 | rr->expire = 0; // Forget about all the leases, start fresh |
| 1142 | rr->uselease = mDNStrue; |
| 1143 | rr->updateid = zeroID; |
| 1144 | rr->SRVChanged = mDNSfalse; |
| 1145 | rr->updateError = mStatus_NoError; |
| 1146 | // RestartRecordGetZoneData calls this function whenever a new interface gets registered with core. |
| 1147 | // The records might already be registered with the server and hence could have NAT state. |
| 1148 | if (rr->NATinfo.clientContext) |
| 1149 | { |
| 1150 | mDNS_StopNATOperation_internal(m, &rr->NATinfo); |
| 1151 | rr->NATinfo.clientContext = mDNSNULL; |
| 1152 | } |
| 1153 | if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; } |
| 1154 | if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } |
| 1155 | if (m->NextuDNSEvent - (rr->LastAPTime + rr->ThisAPInterval) >= 0) |
| 1156 | m->NextuDNSEvent = (rr->LastAPTime + rr->ThisAPInterval); |
| 1157 | } |
| 1158 | |
| 1159 | // Two records qualify to be local duplicates if: |
| 1160 | // (a) the RecordTypes are the same, or |
| 1161 | // (b) one is Unique and the other Verified |
| 1162 | // (c) either is in the process of deregistering |
| 1163 | #define RecordLDT(A,B) ((A)->resrec.RecordType == (B)->resrec.RecordType || \ |
| 1164 | ((A)->resrec.RecordType | (B)->resrec.RecordType) == (kDNSRecordTypeUnique | kDNSRecordTypeVerified) || \ |
| 1165 | ((A)->resrec.RecordType == kDNSRecordTypeDeregistering || (B)->resrec.RecordType == kDNSRecordTypeDeregistering)) |
| 1166 | |
| 1167 | #define RecordIsLocalDuplicate(A,B) \ |
| 1168 | ((A)->resrec.InterfaceID == (B)->resrec.InterfaceID && RecordLDT((A),(B)) && IdenticalResourceRecord(& (A)->resrec, & (B)->resrec)) |
| 1169 | |
| 1170 | mDNSlocal AuthRecord *CheckAuthIdenticalRecord(AuthHash *r, AuthRecord *rr) |
| 1171 | { |
| 1172 | const AuthGroup *a; |
| 1173 | AuthRecord *rp; |
| 1174 | |
| 1175 | a = AuthGroupForRecord(r, &rr->resrec); |
| 1176 | if (!a) return mDNSNULL; |
| 1177 | rp = a->members; |
| 1178 | while (rp) |
| 1179 | { |
| 1180 | if (!RecordIsLocalDuplicate(rp, rr)) |
| 1181 | rp = rp->next; |
| 1182 | else |
| 1183 | { |
| 1184 | if (rp->resrec.RecordType == kDNSRecordTypeDeregistering) |
| 1185 | { |
| 1186 | rp->AnnounceCount = 0; |
| 1187 | rp = rp->next; |
| 1188 | } |
| 1189 | else return rp; |
| 1190 | } |
| 1191 | } |
| 1192 | return (mDNSNULL); |
| 1193 | } |
| 1194 | |
| 1195 | mDNSlocal mDNSBool CheckAuthRecordConflict(AuthHash *r, AuthRecord *rr) |
| 1196 | { |
| 1197 | const AuthGroup *a; |
| 1198 | const AuthRecord *rp; |
| 1199 | |
| 1200 | a = AuthGroupForRecord(r, &rr->resrec); |
| 1201 | if (!a) return mDNSfalse; |
| 1202 | rp = a->members; |
| 1203 | while (rp) |
| 1204 | { |
| 1205 | const AuthRecord *s1 = rr->RRSet ? rr->RRSet : rr; |
| 1206 | const AuthRecord *s2 = rp->RRSet ? rp->RRSet : rp; |
| 1207 | if (s1 != s2 && SameResourceRecordSignature(rp, rr) && !IdenticalSameNameRecord(&rp->resrec, &rr->resrec)) |
| 1208 | return mDNStrue; |
| 1209 | else |
| 1210 | rp = rp->next; |
| 1211 | } |
| 1212 | return (mDNSfalse); |
| 1213 | } |
| 1214 | |
| 1215 | // checks to see if "rr" is already present |
| 1216 | mDNSlocal AuthRecord *CheckAuthSameRecord(AuthHash *r, AuthRecord *rr) |
| 1217 | { |
| 1218 | const AuthGroup *a; |
| 1219 | AuthRecord *rp; |
| 1220 | |
| 1221 | a = AuthGroupForRecord(r, &rr->resrec); |
| 1222 | if (!a) return mDNSNULL; |
| 1223 | rp = a->members; |
| 1224 | while (rp) |
| 1225 | { |
| 1226 | if (rp != rr) |
| 1227 | rp = rp->next; |
| 1228 | else |
| 1229 | { |
| 1230 | return rp; |
| 1231 | } |
| 1232 | } |
| 1233 | return (mDNSNULL); |
| 1234 | } |
| 1235 | |
| 1236 | |
| 1237 | mDNSlocal void DecrementAutoTargetServices(mDNS *const m, AuthRecord *const rr) |
| 1238 | { |
| 1239 | if (RRLocalOnly(rr)) |
| 1240 | { |
| 1241 | // A sanity check, this should be prevented in calling code. |
| 1242 | LogInfo("DecrementAutoTargetServices: called for RRLocalOnly() record: %s" , ARDisplayString(m, rr)); |
| 1243 | return; |
| 1244 | } |
| 1245 | |
| 1246 | if (!AuthRecord_uDNS(rr) && rr->resrec.rrtype == kDNSType_SRV && rr->AutoTarget == Target_AutoHost) |
| 1247 | { |
| 1248 | // If about to get rid of the last advertised service |
| 1249 | if (m->AutoTargetServices == 1) |
| 1250 | DeadvertiseAllInterfaceRecords(m); |
| 1251 | |
| 1252 | m->AutoTargetServices--; |
| 1253 | LogInfo("DecrementAutoTargetServices: AutoTargetServices %d Record %s" , m->AutoTargetServices, ARDisplayString(m, rr)); |
| 1254 | } |
| 1255 | |
| 1256 | #if BONJOUR_ON_DEMAND |
| 1257 | if (!AuthRecord_uDNS(rr)) |
| 1258 | { |
| 1259 | if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) |
| 1260 | m->NextBonjourDisableTime = NonZeroTime(m->timenow + (BONJOUR_DISABLE_DELAY * mDNSPlatformOneSecond)); |
| 1261 | m->NumAllInterfaceRecords--; |
| 1262 | LogInfo("DecrementAutoTargetServices: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %s" , |
| 1263 | m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, ARDisplayString(m, rr)); |
| 1264 | } |
| 1265 | #endif // BONJOUR_ON_DEMAND |
| 1266 | } |
| 1267 | |
| 1268 | mDNSlocal void IncrementAutoTargetServices(mDNS *const m, AuthRecord *const rr) |
| 1269 | { |
| 1270 | mDNSBool enablingBonjour = 0; |
| 1271 | |
| 1272 | if (RRLocalOnly(rr)) |
| 1273 | { |
| 1274 | // A sanity check, this should be prevented in calling code. |
| 1275 | LogInfo("IncrementAutoTargetServices: called for RRLocalOnly() record: %s" , ARDisplayString(m, rr)); |
| 1276 | return; |
| 1277 | } |
| 1278 | |
| 1279 | #if BONJOUR_ON_DEMAND |
| 1280 | if (!AuthRecord_uDNS(rr)) |
| 1281 | { |
| 1282 | m->NumAllInterfaceRecords++; |
| 1283 | LogInfo("IncrementAutoTargetServices: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %s" , |
| 1284 | m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, ARDisplayString(m, rr)); |
| 1285 | if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) |
| 1286 | { |
| 1287 | m->NextBonjourDisableTime = 0; |
| 1288 | if (m->BonjourEnabled == 0) |
| 1289 | { |
| 1290 | // Enable Bonjour immediately by scheduling network changed processing where |
| 1291 | // we will join the multicast group on each active interface. |
| 1292 | m->BonjourEnabled = 1; |
| 1293 | enablingBonjour = 1; |
| 1294 | m->NetworkChanged = m->timenow; |
| 1295 | } |
| 1296 | } |
| 1297 | } |
| 1298 | #endif // BONJOUR_ON_DEMAND |
| 1299 | |
| 1300 | if (!AuthRecord_uDNS(rr) && rr->resrec.rrtype == kDNSType_SRV && rr->AutoTarget == Target_AutoHost) |
| 1301 | { |
| 1302 | m->AutoTargetServices++; |
| 1303 | LogInfo("IncrementAutoTargetServices: AutoTargetServices %d Record %s" , m->AutoTargetServices, ARDisplayString(m, rr)); |
| 1304 | |
| 1305 | // If this is the first advertised service and we did not just enable Bonjour above, then |
| 1306 | // advertise all the interface records. If we did enable Bonjour above, the interface records will |
| 1307 | // be advertised during the network changed processing scheduled above, so no need |
| 1308 | // to do it here. |
| 1309 | if ((m->AutoTargetServices == 1) && (enablingBonjour == 0)) |
| 1310 | AdvertiseAllInterfaceRecords(m); |
| 1311 | } |
| 1312 | } |
| 1313 | |
| 1314 | mDNSlocal void getKeepaliveRaddr(mDNS *const m, AuthRecord *rr, mDNSAddr *raddr) |
| 1315 | { |
| 1316 | mDNSAddr laddr = zeroAddr; |
| 1317 | mDNSEthAddr eth = zeroEthAddr; |
| 1318 | mDNSIPPort lport = zeroIPPort; |
| 1319 | mDNSIPPort rport = zeroIPPort; |
| 1320 | mDNSu32 timeout = 0; |
| 1321 | mDNSu32 seq = 0; |
| 1322 | mDNSu32 ack = 0; |
| 1323 | mDNSu16 win = 0; |
| 1324 | |
| 1325 | if (mDNS_KeepaliveRecord(&rr->resrec)) |
| 1326 | { |
| 1327 | mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, raddr, ð, &seq, &ack, &lport, &rport, &win); |
| 1328 | if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(raddr) || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport)) |
| 1329 | { |
| 1330 | LogMsg("getKeepaliveRaddr: not a valid record %s for keepalive %#a:%d %#a:%d" , ARDisplayString(m, rr), &laddr, lport.NotAnInteger, raddr, rport.NotAnInteger); |
| 1331 | return; |
| 1332 | } |
| 1333 | } |
| 1334 | } |
| 1335 | |
| 1336 | // Exported so uDNS.c can call this |
| 1337 | mDNSexport mStatus mDNS_Register_internal(mDNS *const m, AuthRecord *const rr) |
| 1338 | { |
| 1339 | domainname *target = GetRRDomainNameTarget(&rr->resrec); |
| 1340 | AuthRecord *r; |
| 1341 | AuthRecord **p = &m->ResourceRecords; |
| 1342 | AuthRecord **d = &m->DuplicateRecords; |
| 1343 | |
| 1344 | if ((mDNSs32)rr->resrec.rroriginalttl <= 0) |
| 1345 | { LogMsg("mDNS_Register_internal: TTL %X should be 1 - 0x7FFFFFFF %s" , rr->resrec.rroriginalttl, ARDisplayString(m, rr)); return(mStatus_BadParamErr); } |
| 1346 | |
| 1347 | if (!rr->resrec.RecordType) |
| 1348 | { LogMsg("mDNS_Register_internal: RecordType must be non-zero %s" , ARDisplayString(m, rr)); return(mStatus_BadParamErr); } |
| 1349 | |
| 1350 | if (m->ShutdownTime) |
| 1351 | { LogMsg("mDNS_Register_internal: Shutting down, can't register %s" , ARDisplayString(m, rr)); return(mStatus_ServiceNotRunning); } |
| 1352 | |
| 1353 | if (m->DivertMulticastAdvertisements && !AuthRecord_uDNS(rr)) |
| 1354 | { |
| 1355 | mDNSInterfaceID previousID = rr->resrec.InterfaceID; |
| 1356 | if (rr->resrec.InterfaceID == mDNSInterface_Any || rr->resrec.InterfaceID == mDNSInterface_P2P) |
| 1357 | { |
| 1358 | rr->resrec.InterfaceID = mDNSInterface_LocalOnly; |
| 1359 | rr->ARType = AuthRecordLocalOnly; |
| 1360 | } |
| 1361 | if (rr->resrec.InterfaceID != mDNSInterface_LocalOnly) |
| 1362 | { |
| 1363 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); |
| 1364 | if (intf && !intf->Advertise) { rr->resrec.InterfaceID = mDNSInterface_LocalOnly; rr->ARType = AuthRecordLocalOnly; } |
| 1365 | } |
| 1366 | if (rr->resrec.InterfaceID != previousID) |
| 1367 | LogInfo("mDNS_Register_internal: Diverting record to local-only %s" , ARDisplayString(m, rr)); |
| 1368 | } |
| 1369 | |
| 1370 | if (RRLocalOnly(rr)) |
| 1371 | { |
| 1372 | if (CheckAuthSameRecord(&m->rrauth, rr)) |
| 1373 | { |
| 1374 | LogMsg("mDNS_Register_internal: ERROR!! Tried to register LocalOnly AuthRecord %p %##s (%s) that's already in the list" , |
| 1375 | rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1376 | return(mStatus_AlreadyRegistered); |
| 1377 | } |
| 1378 | } |
| 1379 | else |
| 1380 | { |
| 1381 | while (*p && *p != rr) p=&(*p)->next; |
| 1382 | if (*p) |
| 1383 | { |
| 1384 | LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the list" , |
| 1385 | rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1386 | return(mStatus_AlreadyRegistered); |
| 1387 | } |
| 1388 | } |
| 1389 | |
| 1390 | while (*d && *d != rr) d=&(*d)->next; |
| 1391 | if (*d) |
| 1392 | { |
| 1393 | LogMsg("mDNS_Register_internal: ERROR!! Tried to register AuthRecord %p %##s (%s) that's already in the Duplicate list" , |
| 1394 | rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1395 | return(mStatus_AlreadyRegistered); |
| 1396 | } |
| 1397 | |
| 1398 | if (rr->DependentOn) |
| 1399 | { |
| 1400 | if (rr->resrec.RecordType == kDNSRecordTypeUnique) |
| 1401 | rr->resrec.RecordType = kDNSRecordTypeVerified; |
| 1402 | else if (rr->resrec.RecordType != kDNSRecordTypeKnownUnique) |
| 1403 | { |
| 1404 | LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn && RecordType != kDNSRecordTypeUnique or kDNSRecordTypeKnownUnique" , |
| 1405 | rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1406 | return(mStatus_Invalid); |
| 1407 | } |
| 1408 | if (!(rr->DependentOn->resrec.RecordType & (kDNSRecordTypeUnique | kDNSRecordTypeVerified | kDNSRecordTypeKnownUnique))) |
| 1409 | { |
| 1410 | LogMsg("mDNS_Register_internal: ERROR! %##s (%s): rr->DependentOn->RecordType bad type %X" , |
| 1411 | rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->DependentOn->resrec.RecordType); |
| 1412 | return(mStatus_Invalid); |
| 1413 | } |
| 1414 | } |
| 1415 | |
| 1416 | rr->next = mDNSNULL; |
| 1417 | |
| 1418 | // Field Group 1: The actual information pertaining to this resource record |
| 1419 | // Set up by client prior to call |
| 1420 | |
| 1421 | // Field Group 2: Persistent metadata for Authoritative Records |
| 1422 | // rr->Additional1 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client |
| 1423 | // rr->Additional2 = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client |
| 1424 | // rr->DependentOn = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client |
| 1425 | // rr->RRSet = set to mDNSNULL in mDNS_SetupResourceRecord; may be overridden by client |
| 1426 | // rr->Callback = already set in mDNS_SetupResourceRecord |
| 1427 | // rr->Context = already set in mDNS_SetupResourceRecord |
| 1428 | // rr->RecordType = already set in mDNS_SetupResourceRecord |
| 1429 | // rr->HostTarget = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client |
| 1430 | // rr->AllowRemoteQuery = set to mDNSfalse in mDNS_SetupResourceRecord; may be overridden by client |
| 1431 | // Make sure target is not uninitialized data, or we may crash writing debugging log messages |
| 1432 | if (rr->AutoTarget && target) target->c[0] = 0; |
| 1433 | |
| 1434 | // Field Group 3: Transient state for Authoritative Records |
| 1435 | rr->Acknowledged = mDNSfalse; |
| 1436 | rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); |
| 1437 | rr->ProbeRestartCount = 0; |
| 1438 | rr->AnnounceCount = InitialAnnounceCount; |
| 1439 | rr->RequireGoodbye = mDNSfalse; |
| 1440 | rr->AnsweredLocalQ = mDNSfalse; |
| 1441 | rr->IncludeInProbe = mDNSfalse; |
| 1442 | rr->ImmedUnicast = mDNSfalse; |
| 1443 | rr->SendNSECNow = mDNSNULL; |
| 1444 | rr->ImmedAnswer = mDNSNULL; |
| 1445 | rr->ImmedAdditional = mDNSNULL; |
| 1446 | rr->SendRNow = mDNSNULL; |
| 1447 | rr->v4Requester = zerov4Addr; |
| 1448 | rr->v6Requester = zerov6Addr; |
| 1449 | rr->NextResponse = mDNSNULL; |
| 1450 | rr->NR_AnswerTo = mDNSNULL; |
| 1451 | rr->NR_AdditionalTo = mDNSNULL; |
| 1452 | if (!rr->AutoTarget) InitializeLastAPTime(m, rr); |
| 1453 | // rr->LastAPTime = Set for us in InitializeLastAPTime() |
| 1454 | // rr->LastMCTime = Set for us in InitializeLastAPTime() |
| 1455 | // rr->LastMCInterface = Set for us in InitializeLastAPTime() |
| 1456 | rr->NewRData = mDNSNULL; |
| 1457 | rr->newrdlength = 0; |
| 1458 | rr->UpdateCallback = mDNSNULL; |
| 1459 | rr->UpdateCredits = kMaxUpdateCredits; |
| 1460 | rr->NextUpdateCredit = 0; |
| 1461 | rr->UpdateBlocked = 0; |
| 1462 | |
| 1463 | // For records we're holding as proxy (except reverse-mapping PTR records) two announcements is sufficient |
| 1464 | if (rr->WakeUp.HMAC.l[0] && !rr->AddressProxy.type) rr->AnnounceCount = 2; |
| 1465 | |
| 1466 | // Field Group 4: Transient uDNS state for Authoritative Records |
| 1467 | rr->state = regState_Zero; |
| 1468 | rr->uselease = 0; |
| 1469 | rr->expire = 0; |
| 1470 | rr->Private = 0; |
| 1471 | rr->updateid = zeroID; |
| 1472 | rr->updateIntID = zeroOpaque64; |
| 1473 | rr->zone = rr->resrec.name; |
| 1474 | rr->nta = mDNSNULL; |
| 1475 | rr->tcp = mDNSNULL; |
| 1476 | rr->OrigRData = 0; |
| 1477 | rr->OrigRDLen = 0; |
| 1478 | rr->InFlightRData = 0; |
| 1479 | rr->InFlightRDLen = 0; |
| 1480 | rr->QueuedRData = 0; |
| 1481 | rr->QueuedRDLen = 0; |
| 1482 | //mDNSPlatformMemZero(&rr->NATinfo, sizeof(rr->NATinfo)); |
| 1483 | // We should be recording the actual internal port for this service record here. Once we initiate our NAT mapping |
| 1484 | // request we'll subsequently overwrite srv.port with the allocated external NAT port -- potentially multiple |
| 1485 | // times with different values if the external NAT port changes during the lifetime of the service registration. |
| 1486 | //if (rr->resrec.rrtype == kDNSType_SRV) rr->NATinfo.IntPort = rr->resrec.rdata->u.srv.port; |
| 1487 | |
| 1488 | // rr->resrec.interface = already set in mDNS_SetupResourceRecord |
| 1489 | // rr->resrec.name->c = MUST be set by client |
| 1490 | // rr->resrec.rrtype = already set in mDNS_SetupResourceRecord |
| 1491 | // rr->resrec.rrclass = already set in mDNS_SetupResourceRecord |
| 1492 | // rr->resrec.rroriginalttl = already set in mDNS_SetupResourceRecord |
| 1493 | // rr->resrec.rdata = MUST be set by client, unless record type is CNAME or PTR and rr->HostTarget is set |
| 1494 | |
| 1495 | // BIND named (name daemon) doesn't allow TXT records with zero-length rdata. This is strictly speaking correct, |
| 1496 | // since RFC 1035 specifies a TXT record as "One or more <character-string>s", not "Zero or more <character-string>s". |
| 1497 | // Since some legacy apps try to create zero-length TXT records, we'll silently correct it here. |
| 1498 | if (rr->resrec.rrtype == kDNSType_TXT && rr->resrec.rdlength == 0) { rr->resrec.rdlength = 1; rr->resrec.rdata->u.txt.c[0] = 0; } |
| 1499 | |
| 1500 | if (rr->AutoTarget) |
| 1501 | { |
| 1502 | SetTargetToHostName(m, rr); // Also sets rdlength and rdestimate for us, and calls InitializeLastAPTime(); |
| 1503 | #ifndef UNICAST_DISABLED |
| 1504 | // If we have no target record yet, SetTargetToHostName will set rr->state == regState_NoTarget |
| 1505 | // In this case we leave the record half-formed in the list, and later we'll remove it from the list and re-add it properly. |
| 1506 | if (rr->state == regState_NoTarget) |
| 1507 | { |
| 1508 | // Initialize the target so that we don't crash while logging etc. |
| 1509 | domainname *tar = GetRRDomainNameTarget(&rr->resrec); |
| 1510 | if (tar) tar->c[0] = 0; |
| 1511 | LogInfo("mDNS_Register_internal: record %s in NoTarget state" , ARDisplayString(m, rr)); |
| 1512 | } |
| 1513 | #endif |
| 1514 | } |
| 1515 | else |
| 1516 | { |
| 1517 | rr->resrec.rdlength = GetRDLength(&rr->resrec, mDNSfalse); |
| 1518 | rr->resrec.rdestimate = GetRDLength(&rr->resrec, mDNStrue); |
| 1519 | } |
| 1520 | |
| 1521 | if (!ValidateDomainName(rr->resrec.name)) |
| 1522 | { LogMsg("Attempt to register record with invalid name: %s" , ARDisplayString(m, rr)); return(mStatus_Invalid); } |
| 1523 | |
| 1524 | // Don't do this until *after* we've set rr->resrec.rdlength |
| 1525 | if (!ValidateRData(rr->resrec.rrtype, rr->resrec.rdlength, rr->resrec.rdata)) |
| 1526 | { LogMsg("Attempt to register record with invalid rdata: %s" , ARDisplayString(m, rr)); return(mStatus_Invalid); } |
| 1527 | |
| 1528 | rr->resrec.namehash = DomainNameHashValue(rr->resrec.name); |
| 1529 | rr->resrec.rdatahash = target ? DomainNameHashValue(target) : RDataHashValue(&rr->resrec); |
| 1530 | |
| 1531 | if (RRLocalOnly(rr)) |
| 1532 | { |
| 1533 | // If this is supposed to be unique, make sure we don't have any name conflicts. |
| 1534 | // If we found a conflict, we may still want to insert the record in the list but mark it appropriately |
| 1535 | // (kDNSRecordTypeDeregistering) so that we deliver RMV events to the application. But this causes more |
| 1536 | // complications and not clear whether there are any benefits. See rdar:9304275 for details. |
| 1537 | // Hence, just bail out. |
| 1538 | // This comment is doesn’t make any sense. -- SC |
| 1539 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 1540 | { |
| 1541 | if (CheckAuthRecordConflict(&m->rrauth, rr)) |
| 1542 | { |
| 1543 | LogInfo("mDNS_Register_internal: Name conflict %s (%p), InterfaceID %p" , ARDisplayString(m, rr), rr, rr->resrec.InterfaceID); |
| 1544 | return mStatus_NameConflict; |
| 1545 | } |
| 1546 | } |
| 1547 | } |
| 1548 | |
| 1549 | // For uDNS records, we don't support duplicate checks at this time. |
| 1550 | #ifndef UNICAST_DISABLED |
| 1551 | if (AuthRecord_uDNS(rr)) |
| 1552 | { |
| 1553 | if (!m->NewLocalRecords) m->NewLocalRecords = rr; |
| 1554 | // When we called SetTargetToHostName, it may have caused mDNS_Register_internal to be re-entered, appending new |
| 1555 | // records to the list, so we now need to update p to advance to the new end to the list before appending our new record. |
| 1556 | // Note that for AutoTunnel this should never happen, but this check makes the code future-proof. |
| 1557 | while (*p) p=&(*p)->next; |
| 1558 | *p = rr; |
| 1559 | if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified; |
| 1560 | rr->ProbeCount = 0; |
| 1561 | rr->ProbeRestartCount = 0; |
| 1562 | rr->AnnounceCount = 0; |
| 1563 | if (rr->state != regState_NoTarget) ActivateUnicastRegistration(m, rr); |
| 1564 | return(mStatus_NoError); // <--- Note: For unicast records, code currently bails out at this point |
| 1565 | } |
| 1566 | #endif |
| 1567 | |
| 1568 | // Now that we've finished building our new record, make sure it's not identical to one we already have |
| 1569 | if (RRLocalOnly(rr)) |
| 1570 | { |
| 1571 | rr->ProbeCount = 0; |
| 1572 | rr->ProbeRestartCount = 0; |
| 1573 | rr->AnnounceCount = 0; |
| 1574 | r = CheckAuthIdenticalRecord(&m->rrauth, rr); |
| 1575 | } |
| 1576 | else |
| 1577 | { |
| 1578 | for (r = m->ResourceRecords; r; r=r->next) |
| 1579 | if (RecordIsLocalDuplicate(r, rr)) |
| 1580 | { |
| 1581 | if (r->resrec.RecordType == kDNSRecordTypeDeregistering) r->AnnounceCount = 0; |
| 1582 | else break; |
| 1583 | } |
| 1584 | } |
| 1585 | |
| 1586 | if (r) |
| 1587 | { |
| 1588 | LogInfo("mDNS_Register_internal: Adding to duplicate list %s" , ARDisplayString(m,rr)); |
| 1589 | *d = rr; |
| 1590 | // If the previous copy of this record is already verified unique, |
| 1591 | // then indicate that we should move this record promptly to kDNSRecordTypeUnique state. |
| 1592 | // Setting ProbeCount to zero will cause SendQueries() to advance this record to |
| 1593 | // kDNSRecordTypeVerified state and call the client callback at the next appropriate time. |
| 1594 | if (rr->resrec.RecordType == kDNSRecordTypeUnique && r->resrec.RecordType == kDNSRecordTypeVerified) |
| 1595 | rr->ProbeCount = 0; |
| 1596 | } |
| 1597 | else |
| 1598 | { |
| 1599 | LogInfo("mDNS_Register_internal: Adding to active record list %s" , ARDisplayString(m,rr)); |
| 1600 | if (RRLocalOnly(rr)) |
| 1601 | { |
| 1602 | AuthGroup *ag; |
| 1603 | ag = InsertAuthRecord(m, &m->rrauth, rr); |
| 1604 | if (ag && !ag->NewLocalOnlyRecords) |
| 1605 | { |
| 1606 | m->NewLocalOnlyRecords = mDNStrue; |
| 1607 | ag->NewLocalOnlyRecords = rr; |
| 1608 | } |
| 1609 | // No probing for LocalOnly records; acknowledge them right away |
| 1610 | if (rr->resrec.RecordType == kDNSRecordTypeUnique) rr->resrec.RecordType = kDNSRecordTypeVerified; |
| 1611 | AcknowledgeRecord(m, rr); |
| 1612 | return(mStatus_NoError); |
| 1613 | } |
| 1614 | else |
| 1615 | { |
| 1616 | if (!m->NewLocalRecords) m->NewLocalRecords = rr; |
| 1617 | *p = rr; |
| 1618 | } |
| 1619 | } |
| 1620 | |
| 1621 | if (!AuthRecord_uDNS(rr)) // This check is superfluous, given that for unicast records we (currently) bail out above |
| 1622 | { |
| 1623 | // We have inserted the record in the list. See if we have to advertise the A/AAAA, HINFO, PTR records. |
| 1624 | IncrementAutoTargetServices(m, rr); |
| 1625 | |
| 1626 | // For records that are not going to probe, acknowledge them right away |
| 1627 | if (rr->resrec.RecordType != kDNSRecordTypeUnique && rr->resrec.RecordType != kDNSRecordTypeDeregistering) |
| 1628 | AcknowledgeRecord(m, rr); |
| 1629 | |
| 1630 | // Adding a record may affect whether or not we should sleep |
| 1631 | mDNS_UpdateAllowSleep(m); |
| 1632 | } |
| 1633 | |
| 1634 | // If this is a non-sleep proxy keepalive record, fetch the MAC address of the remote host. |
| 1635 | // This is used by the in-NIC proxy to send the keepalive packets. |
| 1636 | if (!rr->WakeUp.HMAC.l[0] && mDNS_KeepaliveRecord(&rr->resrec)) |
| 1637 | { |
| 1638 | mDNSAddr raddr; |
| 1639 | // Set the record type to known unique to prevent probing keep alive records. |
| 1640 | // Also make sure we do not announce the keepalive records. |
| 1641 | rr->resrec.RecordType = kDNSRecordTypeKnownUnique; |
| 1642 | rr->AnnounceCount = 0; |
| 1643 | getKeepaliveRaddr(m, rr, &raddr); |
| 1644 | // This is an asynchronous call. Once the remote MAC address is available, helper will schedule an |
| 1645 | // asynchronous task to update the resource record |
| 1646 | mDNSPlatformGetRemoteMacAddr(&raddr); |
| 1647 | } |
| 1648 | |
| 1649 | return(mStatus_NoError); |
| 1650 | } |
| 1651 | |
| 1652 | mDNSlocal void RecordProbeFailure(mDNS *const m, const AuthRecord *const rr) |
| 1653 | { |
| 1654 | m->ProbeFailTime = m->timenow; |
| 1655 | m->NumFailedProbes++; |
| 1656 | // If we've had fifteen or more probe failures, rate-limit to one every five seconds. |
| 1657 | // If a bunch of hosts have all been configured with the same name, then they'll all |
| 1658 | // conflict and run through the same series of names: name-2, name-3, name-4, etc., |
| 1659 | // up to name-10. After that they'll start adding random increments in the range 1-100, |
| 1660 | // so they're more likely to branch out in the available namespace and settle on a set of |
| 1661 | // unique names quickly. If after five more tries the host is still conflicting, then we |
| 1662 | // may have a serious problem, so we start rate-limiting so we don't melt down the network. |
| 1663 | if (m->NumFailedProbes >= 15) |
| 1664 | { |
| 1665 | m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5); |
| 1666 | LogMsg("Excessive name conflicts (%lu) for %##s (%s); rate limiting in effect" , |
| 1667 | m->NumFailedProbes, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1668 | } |
| 1669 | } |
| 1670 | |
| 1671 | mDNSlocal void CompleteRDataUpdate(mDNS *const m, AuthRecord *const rr) |
| 1672 | { |
| 1673 | RData *OldRData = rr->resrec.rdata; |
| 1674 | mDNSu16 OldRDLen = rr->resrec.rdlength; |
| 1675 | SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); // Update our rdata |
| 1676 | rr->NewRData = mDNSNULL; // Clear the NewRData pointer ... |
| 1677 | if (rr->UpdateCallback) |
| 1678 | rr->UpdateCallback(m, rr, OldRData, OldRDLen); // ... and let the client know |
| 1679 | } |
| 1680 | |
| 1681 | // Note: mDNS_Deregister_internal can call a user callback, which may change the record list and/or question list. |
| 1682 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 1683 | // Exported so uDNS.c can call this |
| 1684 | mDNSexport mStatus mDNS_Deregister_internal(mDNS *const m, AuthRecord *const rr, mDNS_Dereg_type drt) |
| 1685 | { |
| 1686 | AuthRecord *r2; |
| 1687 | mDNSu8 RecordType = rr->resrec.RecordType; |
| 1688 | AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records |
| 1689 | mDNSBool dupList = mDNSfalse; |
| 1690 | |
| 1691 | if (RRLocalOnly(rr)) |
| 1692 | { |
| 1693 | AuthGroup *a; |
| 1694 | AuthRecord **rp; |
| 1695 | |
| 1696 | a = AuthGroupForRecord(&m->rrauth, &rr->resrec); |
| 1697 | if (!a) return mDNSfalse; |
| 1698 | rp = &a->members; |
| 1699 | while (*rp && *rp != rr) rp=&(*rp)->next; |
| 1700 | p = rp; |
| 1701 | } |
| 1702 | else |
| 1703 | { |
| 1704 | while (*p && *p != rr) p=&(*p)->next; |
| 1705 | } |
| 1706 | |
| 1707 | if (*p) |
| 1708 | { |
| 1709 | // We found our record on the main list. See if there are any duplicates that need special handling. |
| 1710 | if (drt == mDNS_Dereg_conflict) // If this was a conflict, see that all duplicates get the same treatment |
| 1711 | { |
| 1712 | // Scan for duplicates of rr, and mark them for deregistration at the end of this routine, after we've finished |
| 1713 | // deregistering rr. We need to do this scan *before* we give the client the chance to free and reuse the rr memory. |
| 1714 | for (r2 = m->DuplicateRecords; r2; r2=r2->next) if (RecordIsLocalDuplicate(r2, rr)) r2->ProbeCount = 0xFF; |
| 1715 | } |
| 1716 | else |
| 1717 | { |
| 1718 | // Before we delete the record (and potentially send a goodbye packet) |
| 1719 | // first see if we have a record on the duplicate list ready to take over from it. |
| 1720 | AuthRecord **d = &m->DuplicateRecords; |
| 1721 | while (*d && !RecordIsLocalDuplicate(*d, rr)) d=&(*d)->next; |
| 1722 | if (*d) |
| 1723 | { |
| 1724 | AuthRecord *dup = *d; |
| 1725 | debugf("mDNS_Register_internal: Duplicate record %p taking over from %p %##s (%s)" , |
| 1726 | dup, rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1727 | *d = dup->next; // Cut replacement record from DuplicateRecords list |
| 1728 | if (RRLocalOnly(rr)) |
| 1729 | { |
| 1730 | dup->next = mDNSNULL; |
| 1731 | if (!InsertAuthRecord(m, &m->rrauth, dup)) LogMsg("mDNS_Deregister_internal: ERROR!! cannot insert %s" , ARDisplayString(m, dup)); |
| 1732 | } |
| 1733 | else |
| 1734 | { |
| 1735 | dup->next = rr->next; // And then... |
| 1736 | rr->next = dup; // ... splice it in right after the record we're about to delete |
| 1737 | } |
| 1738 | dup->resrec.RecordType = rr->resrec.RecordType; |
| 1739 | dup->ProbeCount = rr->ProbeCount; |
| 1740 | dup->ProbeRestartCount = rr->ProbeRestartCount; |
| 1741 | dup->AnnounceCount = rr->AnnounceCount; |
| 1742 | dup->RequireGoodbye = rr->RequireGoodbye; |
| 1743 | dup->AnsweredLocalQ = rr->AnsweredLocalQ; |
| 1744 | dup->ImmedAnswer = rr->ImmedAnswer; |
| 1745 | dup->ImmedUnicast = rr->ImmedUnicast; |
| 1746 | dup->ImmedAdditional = rr->ImmedAdditional; |
| 1747 | dup->v4Requester = rr->v4Requester; |
| 1748 | dup->v6Requester = rr->v6Requester; |
| 1749 | dup->ThisAPInterval = rr->ThisAPInterval; |
| 1750 | dup->LastAPTime = rr->LastAPTime; |
| 1751 | dup->LastMCTime = rr->LastMCTime; |
| 1752 | dup->LastMCInterface = rr->LastMCInterface; |
| 1753 | dup->Private = rr->Private; |
| 1754 | dup->state = rr->state; |
| 1755 | rr->RequireGoodbye = mDNSfalse; |
| 1756 | rr->AnsweredLocalQ = mDNSfalse; |
| 1757 | } |
| 1758 | } |
| 1759 | } |
| 1760 | else |
| 1761 | { |
| 1762 | // We didn't find our record on the main list; try the DuplicateRecords list instead. |
| 1763 | p = &m->DuplicateRecords; |
| 1764 | while (*p && *p != rr) p=&(*p)->next; |
| 1765 | // If we found our record on the duplicate list, then make sure we don't send a goodbye for it |
| 1766 | if (*p) |
| 1767 | { |
| 1768 | // Duplicate records are not used for sending wakeups or goodbyes. Hence, deregister them |
| 1769 | // immediately. When there is a conflict, we deregister all the conflicting duplicate records |
| 1770 | // also that have been marked above in this function. In that case, we come here and if we don't |
| 1771 | // deregister (unilink from the DuplicateRecords list), we will be recursing infinitely. Hence, |
| 1772 | // clear the HMAC which will cause it to deregister. See <rdar://problem/10380988> for |
| 1773 | // details. |
| 1774 | rr->WakeUp.HMAC = zeroEthAddr; |
| 1775 | rr->RequireGoodbye = mDNSfalse; |
| 1776 | rr->resrec.RecordType = kDNSRecordTypeDeregistering; |
| 1777 | dupList = mDNStrue; |
| 1778 | } |
| 1779 | if (*p) debugf("mDNS_Deregister_internal: Deleting DuplicateRecord %p %##s (%s)" , |
| 1780 | rr, rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1781 | } |
| 1782 | |
| 1783 | if (!*p) |
| 1784 | { |
| 1785 | // No need to log an error message if we already know this is a potentially repeated deregistration |
| 1786 | if (drt != mDNS_Dereg_repeat) |
| 1787 | LogMsg("mDNS_Deregister_internal: Record %p not found in list %s" , rr, ARDisplayString(m,rr)); |
| 1788 | return(mStatus_BadReferenceErr); |
| 1789 | } |
| 1790 | |
| 1791 | // If this is a shared record and we've announced it at least once, |
| 1792 | // we need to retract that announcement before we delete the record |
| 1793 | |
| 1794 | // If this is a record (including mDNSInterface_LocalOnly records) for which we've given local-only answers then |
| 1795 | // it's tempting to just do "AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse)" here, but that would not not be safe. |
| 1796 | // The AnswerAllLocalQuestionsWithLocalAuthRecord routine walks the question list invoking client callbacks, using the "m->CurrentQuestion" |
| 1797 | // mechanism to cope with the client callback modifying the question list while that's happening. |
| 1798 | // However, mDNS_Deregister could have been called from a client callback (e.g. from the domain enumeration callback FoundDomain) |
| 1799 | // which means that the "m->CurrentQuestion" mechanism is already in use to protect that list, so we can't use it twice. |
| 1800 | // More generally, if we invoke callbacks from within a client callback, then those callbacks could deregister other |
| 1801 | // records, thereby invoking yet more callbacks, without limit. |
| 1802 | // The solution is to defer delivering the "Remove" events until mDNS_Execute time, just like we do for sending |
| 1803 | // actual goodbye packets. |
| 1804 | |
| 1805 | #ifndef UNICAST_DISABLED |
| 1806 | if (AuthRecord_uDNS(rr)) |
| 1807 | { |
| 1808 | if (rr->RequireGoodbye) |
| 1809 | { |
| 1810 | if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } |
| 1811 | rr->resrec.RecordType = kDNSRecordTypeDeregistering; |
| 1812 | m->LocalRemoveEvents = mDNStrue; |
| 1813 | uDNS_DeregisterRecord(m, rr); |
| 1814 | // At this point unconditionally we bail out |
| 1815 | // Either uDNS_DeregisterRecord will have completed synchronously, and called CompleteDeregistration, |
| 1816 | // which calls us back here with RequireGoodbye set to false, or it will have initiated the deregistration |
| 1817 | // process and will complete asynchronously. Either way we don't need to do anything more here. |
| 1818 | return(mStatus_NoError); |
| 1819 | } |
| 1820 | // Sometimes the records don't complete proper deregistration i.e., don't wait for a response |
| 1821 | // from the server. In that case, if the records have been part of a group update, clear the |
| 1822 | // state here. Some recors e.g., AutoTunnel gets reused without ever being completely initialized |
| 1823 | rr->updateid = zeroID; |
| 1824 | |
| 1825 | // We defer cleaning up NAT state only after sending goodbyes. This is important because |
| 1826 | // RecordRegistrationGotZoneData guards against creating NAT state if clientContext is non-NULL. |
| 1827 | // This happens today when we turn on/off interface where we get multiple network transitions |
| 1828 | // and RestartRecordGetZoneData triggers re-registration of the resource records even though |
| 1829 | // they may be in Registered state which causes NAT information to be setup multiple times. Defering |
| 1830 | // the cleanup here keeps clientContext non-NULL and hence prevents that. Note that cleaning up |
| 1831 | // NAT state here takes care of the case where we did not send goodbyes at all. |
| 1832 | if (rr->NATinfo.clientContext) |
| 1833 | { |
| 1834 | mDNS_StopNATOperation_internal(m, &rr->NATinfo); |
| 1835 | rr->NATinfo.clientContext = mDNSNULL; |
| 1836 | } |
| 1837 | if (rr->nta) { CancelGetZoneData(m, rr->nta); rr->nta = mDNSNULL; } |
| 1838 | if (rr->tcp) { DisposeTCPConn(rr->tcp); rr->tcp = mDNSNULL; } |
| 1839 | } |
| 1840 | #endif // UNICAST_DISABLED |
| 1841 | |
| 1842 | if (RecordType == kDNSRecordTypeUnregistered) |
| 1843 | LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeUnregistered" , ARDisplayString(m, rr)); |
| 1844 | else if (RecordType == kDNSRecordTypeDeregistering) |
| 1845 | { |
| 1846 | LogMsg("mDNS_Deregister_internal: %s already marked kDNSRecordTypeDeregistering" , ARDisplayString(m, rr)); |
| 1847 | return(mStatus_BadReferenceErr); |
| 1848 | } |
| 1849 | |
| 1850 | // <rdar://problem/7457925> Local-only questions don't get remove events for unique records |
| 1851 | // We may want to consider changing this code so that we generate local-only question "rmv" |
| 1852 | // events (and maybe goodbye packets too) for unique records as well as for shared records |
| 1853 | // Note: If we change the logic for this "if" statement, need to ensure that the code in |
| 1854 | // CompleteDeregistration() sets the appropriate state variables to gaurantee that "else" |
| 1855 | // clause will execute here and the record will be cut from the list. |
| 1856 | if (rr->WakeUp.HMAC.l[0] || |
| 1857 | (RecordType == kDNSRecordTypeShared && (rr->RequireGoodbye || rr->AnsweredLocalQ))) |
| 1858 | { |
| 1859 | verbosedebugf("mDNS_Deregister_internal: Starting deregistration for %s" , ARDisplayString(m, rr)); |
| 1860 | rr->resrec.RecordType = kDNSRecordTypeDeregistering; |
| 1861 | rr->resrec.rroriginalttl = 0; |
| 1862 | rr->AnnounceCount = rr->WakeUp.HMAC.l[0] ? WakeupCount : (drt == mDNS_Dereg_rapid) ? 1 : GoodbyeCount; |
| 1863 | rr->ThisAPInterval = mDNSPlatformOneSecond * 2; |
| 1864 | rr->LastAPTime = m->timenow - rr->ThisAPInterval; |
| 1865 | m->LocalRemoveEvents = mDNStrue; |
| 1866 | if (m->NextScheduledResponse - (m->timenow + mDNSPlatformOneSecond/10) >= 0) |
| 1867 | m->NextScheduledResponse = (m->timenow + mDNSPlatformOneSecond/10); |
| 1868 | } |
| 1869 | else |
| 1870 | { |
| 1871 | if (!dupList && RRLocalOnly(rr)) |
| 1872 | { |
| 1873 | AuthGroup *ag = RemoveAuthRecord(m, &m->rrauth, rr); |
| 1874 | if (ag->NewLocalOnlyRecords == rr) ag->NewLocalOnlyRecords = rr->next; |
| 1875 | } |
| 1876 | else |
| 1877 | { |
| 1878 | *p = rr->next; // Cut this record from the list |
| 1879 | if (m->NewLocalRecords == rr) m->NewLocalRecords = rr->next; |
| 1880 | DecrementAutoTargetServices(m, rr); |
| 1881 | } |
| 1882 | // If someone is about to look at this, bump the pointer forward |
| 1883 | if (m->CurrentRecord == rr) m->CurrentRecord = rr->next; |
| 1884 | rr->next = mDNSNULL; |
| 1885 | |
| 1886 | // Should we generate local remove events here? |
| 1887 | // i.e. something like: |
| 1888 | // if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; } |
| 1889 | |
| 1890 | verbosedebugf("mDNS_Deregister_internal: Deleting record for %s" , ARDisplayString(m, rr)); |
| 1891 | rr->resrec.RecordType = kDNSRecordTypeUnregistered; |
| 1892 | |
| 1893 | if ((drt == mDNS_Dereg_conflict || drt == mDNS_Dereg_repeat) && RecordType == kDNSRecordTypeShared) |
| 1894 | debugf("mDNS_Deregister_internal: Cannot have a conflict on a shared record! %##s (%s)" , |
| 1895 | rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1896 | |
| 1897 | // If we have an update queued up which never executed, give the client a chance to free that memory |
| 1898 | if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client |
| 1899 | |
| 1900 | |
| 1901 | // CAUTION: MUST NOT do anything more with rr after calling rr->Callback(), because the client's callback function |
| 1902 | // is allowed to do anything, including starting/stopping queries, registering/deregistering records, etc. |
| 1903 | // In this case the likely client action to the mStatus_MemFree message is to free the memory, |
| 1904 | // so any attempt to touch rr after this is likely to lead to a crash. |
| 1905 | if (drt != mDNS_Dereg_conflict) |
| 1906 | { |
| 1907 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 1908 | LogInfo("mDNS_Deregister_internal: callback with mStatus_MemFree for %s" , ARDisplayString(m, rr)); |
| 1909 | if (rr->RecordCallback) |
| 1910 | rr->RecordCallback(m, rr, mStatus_MemFree); // MUST NOT touch rr after this |
| 1911 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 1912 | } |
| 1913 | else |
| 1914 | { |
| 1915 | RecordProbeFailure(m, rr); |
| 1916 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 1917 | if (rr->RecordCallback) |
| 1918 | rr->RecordCallback(m, rr, mStatus_NameConflict); // MUST NOT touch rr after this |
| 1919 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 1920 | // Now that we've finished deregistering rr, check our DuplicateRecords list for any that we marked previously. |
| 1921 | // Note that with all the client callbacks going on, by the time we get here all the |
| 1922 | // records we marked may have been explicitly deregistered by the client anyway. |
| 1923 | r2 = m->DuplicateRecords; |
| 1924 | while (r2) |
| 1925 | { |
| 1926 | if (r2->ProbeCount != 0xFF) |
| 1927 | { |
| 1928 | r2 = r2->next; |
| 1929 | } |
| 1930 | else |
| 1931 | { |
| 1932 | #if APPLE_OSX_mDNSResponder |
| 1933 | // See if this record was also registered with any D2D plugins. |
| 1934 | D2D_stop_advertising_record(r2); |
| 1935 | #endif |
| 1936 | mDNS_Deregister_internal(m, r2, mDNS_Dereg_conflict); |
| 1937 | // As this is a duplicate record, it will be unlinked from the list |
| 1938 | // immediately |
| 1939 | r2 = m->DuplicateRecords; |
| 1940 | } |
| 1941 | } |
| 1942 | } |
| 1943 | } |
| 1944 | mDNS_UpdateAllowSleep(m); |
| 1945 | return(mStatus_NoError); |
| 1946 | } |
| 1947 | |
| 1948 | // *************************************************************************** |
| 1949 | #if COMPILER_LIKES_PRAGMA_MARK |
| 1950 | #pragma mark - |
| 1951 | #pragma mark - Packet Sending Functions |
| 1952 | #endif |
| 1953 | |
| 1954 | mDNSlocal void AddRecordToResponseList(AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *add) |
| 1955 | { |
| 1956 | if (rr->NextResponse == mDNSNULL && *nrpp != &rr->NextResponse) |
| 1957 | { |
| 1958 | **nrpp = rr; |
| 1959 | // NR_AdditionalTo must point to a record with NR_AnswerTo set (and not NR_AdditionalTo) |
| 1960 | // If 'add' does not meet this requirement, then follow its NR_AdditionalTo pointer to a record that does |
| 1961 | // The referenced record will definitely be acceptable (by recursive application of this rule) |
| 1962 | if (add && add->NR_AdditionalTo) add = add->NR_AdditionalTo; |
| 1963 | rr->NR_AdditionalTo = add; |
| 1964 | *nrpp = &rr->NextResponse; |
| 1965 | } |
| 1966 | debugf("AddRecordToResponseList: %##s (%s) already in list" , rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 1967 | } |
| 1968 | |
| 1969 | mDNSlocal void AddRRSetAdditionalsToResponseList(mDNS *const m, AuthRecord ***nrpp, AuthRecord *rr, AuthRecord *additional, const mDNSInterfaceID InterfaceID) |
| 1970 | { |
| 1971 | AuthRecord *rr2; |
| 1972 | if (additional->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 1973 | { |
| 1974 | for (rr2 = m->ResourceRecords; rr2; rr2 = rr2->next) |
| 1975 | { |
| 1976 | if ((rr2->resrec.namehash == additional->resrec.namehash) && |
| 1977 | (rr2->resrec.rrtype == additional->resrec.rrtype) && |
| 1978 | (rr2 != additional) && |
| 1979 | (rr2->resrec.RecordType & kDNSRecordTypeUniqueMask) && |
| 1980 | (rr2->resrec.rrclass == additional->resrec.rrclass) && |
| 1981 | ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && |
| 1982 | SameDomainName(rr2->resrec.name, additional->resrec.name)) |
| 1983 | { |
| 1984 | AddRecordToResponseList(nrpp, rr2, rr); |
| 1985 | } |
| 1986 | } |
| 1987 | } |
| 1988 | } |
| 1989 | |
| 1990 | mDNSlocal void AddAdditionalsToResponseList(mDNS *const m, AuthRecord *ResponseRecords, AuthRecord ***nrpp, const mDNSInterfaceID InterfaceID) |
| 1991 | { |
| 1992 | AuthRecord *rr, *rr2; |
| 1993 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) // For each record we plan to put |
| 1994 | { |
| 1995 | // (Note: This is an "if", not a "while". If we add a record, we'll find it again |
| 1996 | // later in the "for" loop, and we will follow further "additional" links then.) |
| 1997 | if (rr->Additional1 && ResourceRecordIsValidInterfaceAnswer(rr->Additional1, InterfaceID)) |
| 1998 | { |
| 1999 | AddRecordToResponseList(nrpp, rr->Additional1, rr); |
| 2000 | AddRRSetAdditionalsToResponseList(m, nrpp, rr, rr->Additional1, InterfaceID); |
| 2001 | } |
| 2002 | |
| 2003 | if (rr->Additional2 && ResourceRecordIsValidInterfaceAnswer(rr->Additional2, InterfaceID)) |
| 2004 | { |
| 2005 | AddRecordToResponseList(nrpp, rr->Additional2, rr); |
| 2006 | AddRRSetAdditionalsToResponseList(m, nrpp, rr, rr->Additional2, InterfaceID); |
| 2007 | } |
| 2008 | |
| 2009 | // For SRV records, automatically add the Address record(s) for the target host |
| 2010 | if (rr->resrec.rrtype == kDNSType_SRV) |
| 2011 | { |
| 2012 | for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records |
| 2013 | if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ... |
| 2014 | ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ... |
| 2015 | rr->resrec.rdatahash == rr2->resrec.namehash && // ... whose name is the name of the SRV target |
| 2016 | SameDomainName(&rr->resrec.rdata->u.srv.target, rr2->resrec.name)) |
| 2017 | AddRecordToResponseList(nrpp, rr2, rr); |
| 2018 | } |
| 2019 | else if (RRTypeIsAddressType(rr->resrec.rrtype)) // For A or AAAA, put counterpart as additional |
| 2020 | { |
| 2021 | for (rr2=m->ResourceRecords; rr2; rr2=rr2->next) // Scan list of resource records |
| 2022 | if (RRTypeIsAddressType(rr2->resrec.rrtype) && // For all address records (A/AAAA) ... |
| 2023 | ResourceRecordIsValidInterfaceAnswer(rr2, InterfaceID) && // ... which are valid for answer ... |
| 2024 | rr->resrec.namehash == rr2->resrec.namehash && // ... and have the same name |
| 2025 | SameDomainName(rr->resrec.name, rr2->resrec.name)) |
| 2026 | AddRecordToResponseList(nrpp, rr2, rr); |
| 2027 | } |
| 2028 | else if (rr->resrec.rrtype == kDNSType_PTR) // For service PTR, see if we want to add DeviceInfo record |
| 2029 | { |
| 2030 | if (ResourceRecordIsValidInterfaceAnswer(&m->DeviceInfo, InterfaceID) && |
| 2031 | SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c)) |
| 2032 | AddRecordToResponseList(nrpp, &m->DeviceInfo, rr); |
| 2033 | } |
| 2034 | } |
| 2035 | } |
| 2036 | |
| 2037 | mDNSlocal int AnonInfoSpace(AnonymousInfo *info) |
| 2038 | { |
| 2039 | ResourceRecord *rr = info->nsec3RR; |
| 2040 | |
| 2041 | // 2 bytes for compressed name + type (2) class (2) TTL (4) rdlength (2) rdata (n) |
| 2042 | return (2 + 10 + rr->rdlength); |
| 2043 | } |
| 2044 | |
| 2045 | mDNSlocal void SendDelayedUnicastResponse(mDNS *const m, const mDNSAddr *const dest, const mDNSInterfaceID InterfaceID) |
| 2046 | { |
| 2047 | AuthRecord *rr; |
| 2048 | AuthRecord *ResponseRecords = mDNSNULL; |
| 2049 | AuthRecord **nrp = &ResponseRecords; |
| 2050 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); |
| 2051 | int AnoninfoSpace = 0; |
| 2052 | |
| 2053 | // Make a list of all our records that need to be unicast to this destination |
| 2054 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2055 | { |
| 2056 | // If we find we can no longer unicast this answer, clear ImmedUnicast |
| 2057 | if (rr->ImmedAnswer == mDNSInterfaceMark || |
| 2058 | mDNSSameIPv4Address(rr->v4Requester, onesIPv4Addr) || |
| 2059 | mDNSSameIPv6Address(rr->v6Requester, onesIPv6Addr) ) |
| 2060 | rr->ImmedUnicast = mDNSfalse; |
| 2061 | |
| 2062 | if (rr->ImmedUnicast && rr->ImmedAnswer == InterfaceID) |
| 2063 | { |
| 2064 | if ((dest->type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->v4Requester, dest->ip.v4)) || |
| 2065 | (dest->type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->v6Requester, dest->ip.v6))) |
| 2066 | { |
| 2067 | rr->ImmedAnswer = mDNSNULL; // Clear the state fields |
| 2068 | rr->ImmedUnicast = mDNSfalse; |
| 2069 | rr->v4Requester = zerov4Addr; |
| 2070 | rr->v6Requester = zerov6Addr; |
| 2071 | |
| 2072 | // Only sent records registered for P2P over P2P interfaces |
| 2073 | if (intf && !mDNSPlatformValidRecordForInterface(rr, intf->InterfaceID)) |
| 2074 | { |
| 2075 | continue; |
| 2076 | } |
| 2077 | |
| 2078 | if (rr->NextResponse == mDNSNULL && nrp != &rr->NextResponse) // rr->NR_AnswerTo |
| 2079 | { |
| 2080 | rr->NR_AnswerTo = NR_AnswerMulticast; |
| 2081 | *nrp = rr; |
| 2082 | nrp = &rr->NextResponse; |
| 2083 | } |
| 2084 | } |
| 2085 | } |
| 2086 | } |
| 2087 | |
| 2088 | AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID); |
| 2089 | |
| 2090 | while (ResponseRecords) |
| 2091 | { |
| 2092 | mDNSu8 *responseptr = m->omsg.data; |
| 2093 | mDNSu8 *newptr; |
| 2094 | InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags); |
| 2095 | |
| 2096 | // Put answers in the packet |
| 2097 | while (ResponseRecords && ResponseRecords->NR_AnswerTo) |
| 2098 | { |
| 2099 | rr = ResponseRecords; |
| 2100 | if (rr->resrec.AnonInfo) |
| 2101 | { |
| 2102 | AnoninfoSpace += AnonInfoSpace(rr->resrec.AnonInfo); |
| 2103 | rr->resrec.AnonInfo->SendNow = mDNSInterfaceMark; |
| 2104 | } |
| 2105 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 2106 | rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it |
| 2107 | |
| 2108 | // Retract the limit by AnoninfoSpace which we need to put the AnoInfo option. |
| 2109 | newptr = PutResourceRecordTTLWithLimit(&m->omsg, responseptr, &m->omsg.h.numAnswers, &rr->resrec, rr->resrec.rroriginalttl, |
| 2110 | m->omsg.data + (AllowedRRSpace(&m->omsg) - AnoninfoSpace)); |
| 2111 | |
| 2112 | rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state |
| 2113 | if (!newptr && m->omsg.h.numAnswers) |
| 2114 | { |
| 2115 | break; // If packet full, send it now |
| 2116 | } |
| 2117 | if (newptr) responseptr = newptr; |
| 2118 | ResponseRecords = rr->NextResponse; |
| 2119 | rr->NextResponse = mDNSNULL; |
| 2120 | rr->NR_AnswerTo = mDNSNULL; |
| 2121 | rr->NR_AdditionalTo = mDNSNULL; |
| 2122 | rr->RequireGoodbye = mDNStrue; |
| 2123 | } |
| 2124 | |
| 2125 | // We have reserved the space for AnonInfo option. PutResourceRecord uses the |
| 2126 | // standard limit (AllowedRRSpace) and we should have space now. |
| 2127 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2128 | { |
| 2129 | if (rr->resrec.AnonInfo && rr->resrec.AnonInfo->SendNow == mDNSInterfaceMark) |
| 2130 | { |
| 2131 | ResourceRecord *nsec3RR = rr->resrec.AnonInfo->nsec3RR; |
| 2132 | |
| 2133 | newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAuthorities, nsec3RR); |
| 2134 | if (newptr) |
| 2135 | { |
| 2136 | responseptr = newptr; |
| 2137 | debugf("SendDelayedUnicastResponse: Added NSEC3 Record %s on %p" , RRDisplayString(m, nsec3RR), intf->InterfaceID); |
| 2138 | } |
| 2139 | else |
| 2140 | { |
| 2141 | // We allocated space and we should not fail. Don't break, we need to clear the SendNow flag. |
| 2142 | LogMsg("SendDelayedUnicastResponse: ERROR!! Cannot Add NSEC3 Record %s on %p" , RRDisplayString(m, nsec3RR), intf->InterfaceID); |
| 2143 | } |
| 2144 | rr->resrec.AnonInfo->SendNow = mDNSNULL; |
| 2145 | } |
| 2146 | } |
| 2147 | |
| 2148 | // Add additionals, if there's space |
| 2149 | while (ResponseRecords && !ResponseRecords->NR_AnswerTo) |
| 2150 | { |
| 2151 | rr = ResponseRecords; |
| 2152 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 2153 | rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it |
| 2154 | newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &rr->resrec); |
| 2155 | rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state |
| 2156 | |
| 2157 | if (newptr) responseptr = newptr; |
| 2158 | if (newptr && m->omsg.h.numAnswers) rr->RequireGoodbye = mDNStrue; |
| 2159 | else if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) rr->ImmedAnswer = mDNSInterfaceMark; |
| 2160 | ResponseRecords = rr->NextResponse; |
| 2161 | rr->NextResponse = mDNSNULL; |
| 2162 | rr->NR_AnswerTo = mDNSNULL; |
| 2163 | rr->NR_AdditionalTo = mDNSNULL; |
| 2164 | } |
| 2165 | |
| 2166 | if (m->omsg.h.numAnswers) |
| 2167 | mDNSSendDNSMessage(m, &m->omsg, responseptr, InterfaceID, mDNSNULL, dest, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse); |
| 2168 | } |
| 2169 | } |
| 2170 | |
| 2171 | // CompleteDeregistration guarantees that on exit the record will have been cut from the m->ResourceRecords list |
| 2172 | // and the client's mStatus_MemFree callback will have been invoked |
| 2173 | mDNSexport void CompleteDeregistration(mDNS *const m, AuthRecord *rr) |
| 2174 | { |
| 2175 | LogInfo("CompleteDeregistration: called for Resource record %s" , ARDisplayString(m, rr)); |
| 2176 | // Clearing rr->RequireGoodbye signals mDNS_Deregister_internal() that |
| 2177 | // it should go ahead and immediately dispose of this registration |
| 2178 | rr->resrec.RecordType = kDNSRecordTypeShared; |
| 2179 | rr->RequireGoodbye = mDNSfalse; |
| 2180 | rr->WakeUp.HMAC = zeroEthAddr; |
| 2181 | if (rr->AnsweredLocalQ) { AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); rr->AnsweredLocalQ = mDNSfalse; } |
| 2182 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); // Don't touch rr after this |
| 2183 | } |
| 2184 | |
| 2185 | // DiscardDeregistrations is used on shutdown and sleep to discard (forcibly and immediately) |
| 2186 | // any deregistering records that remain in the m->ResourceRecords list. |
| 2187 | // DiscardDeregistrations calls mDNS_Deregister_internal which can call a user callback, |
| 2188 | // which may change the record list and/or question list. |
| 2189 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 2190 | mDNSlocal void DiscardDeregistrations(mDNS *const m) |
| 2191 | { |
| 2192 | if (m->CurrentRecord) |
| 2193 | LogMsg("DiscardDeregistrations ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 2194 | m->CurrentRecord = m->ResourceRecords; |
| 2195 | |
| 2196 | while (m->CurrentRecord) |
| 2197 | { |
| 2198 | AuthRecord *rr = m->CurrentRecord; |
| 2199 | if (!AuthRecord_uDNS(rr) && rr->resrec.RecordType == kDNSRecordTypeDeregistering) |
| 2200 | CompleteDeregistration(m, rr); // Don't touch rr after this |
| 2201 | else |
| 2202 | m->CurrentRecord = rr->next; |
| 2203 | } |
| 2204 | } |
| 2205 | |
| 2206 | mDNSlocal mStatus GetLabelDecimalValue(const mDNSu8 *const src, mDNSu8 *dst) |
| 2207 | { |
| 2208 | int i, val = 0; |
| 2209 | if (src[0] < 1 || src[0] > 3) return(mStatus_Invalid); |
| 2210 | for (i=1; i<=src[0]; i++) |
| 2211 | { |
| 2212 | if (src[i] < '0' || src[i] > '9') return(mStatus_Invalid); |
| 2213 | val = val * 10 + src[i] - '0'; |
| 2214 | } |
| 2215 | if (val > 255) return(mStatus_Invalid); |
| 2216 | *dst = (mDNSu8)val; |
| 2217 | return(mStatus_NoError); |
| 2218 | } |
| 2219 | |
| 2220 | mDNSlocal mStatus GetIPv4FromName(mDNSAddr *const a, const domainname *const name) |
| 2221 | { |
| 2222 | int skip = CountLabels(name) - 6; |
| 2223 | if (skip < 0) { LogMsg("GetIPFromName: Need six labels in IPv4 reverse mapping name %##s" , name); return mStatus_Invalid; } |
| 2224 | if (GetLabelDecimalValue(SkipLeadingLabels(name, skip+3)->c, &a->ip.v4.b[0]) || |
| 2225 | GetLabelDecimalValue(SkipLeadingLabels(name, skip+2)->c, &a->ip.v4.b[1]) || |
| 2226 | GetLabelDecimalValue(SkipLeadingLabels(name, skip+1)->c, &a->ip.v4.b[2]) || |
| 2227 | GetLabelDecimalValue(SkipLeadingLabels(name, skip+0)->c, &a->ip.v4.b[3])) return mStatus_Invalid; |
| 2228 | a->type = mDNSAddrType_IPv4; |
| 2229 | return(mStatus_NoError); |
| 2230 | } |
| 2231 | |
| 2232 | #define HexVal(X) ( ((X) >= '0' && (X) <= '9') ? ((X) - '0' ) : \ |
| 2233 | ((X) >= 'A' && (X) <= 'F') ? ((X) - 'A' + 10) : \ |
| 2234 | ((X) >= 'a' && (X) <= 'f') ? ((X) - 'a' + 10) : -1) |
| 2235 | |
| 2236 | mDNSlocal mStatus GetIPv6FromName(mDNSAddr *const a, const domainname *const name) |
| 2237 | { |
| 2238 | int i, h, l; |
| 2239 | const domainname *n; |
| 2240 | |
| 2241 | int skip = CountLabels(name) - 34; |
| 2242 | if (skip < 0) { LogMsg("GetIPFromName: Need 34 labels in IPv6 reverse mapping name %##s" , name); return mStatus_Invalid; } |
| 2243 | |
| 2244 | n = SkipLeadingLabels(name, skip); |
| 2245 | for (i=0; i<16; i++) |
| 2246 | { |
| 2247 | if (n->c[0] != 1) return mStatus_Invalid; |
| 2248 | l = HexVal(n->c[1]); |
| 2249 | n = (const domainname *)(n->c + 2); |
| 2250 | |
| 2251 | if (n->c[0] != 1) return mStatus_Invalid; |
| 2252 | h = HexVal(n->c[1]); |
| 2253 | n = (const domainname *)(n->c + 2); |
| 2254 | |
| 2255 | if (l<0 || h<0) return mStatus_Invalid; |
| 2256 | a->ip.v6.b[15-i] = (mDNSu8)((h << 4) | l); |
| 2257 | } |
| 2258 | |
| 2259 | a->type = mDNSAddrType_IPv6; |
| 2260 | return(mStatus_NoError); |
| 2261 | } |
| 2262 | |
| 2263 | mDNSlocal mDNSs32 ReverseMapDomainType(const domainname *const name) |
| 2264 | { |
| 2265 | int skip = CountLabels(name) - 2; |
| 2266 | if (skip >= 0) |
| 2267 | { |
| 2268 | const domainname *suffix = SkipLeadingLabels(name, skip); |
| 2269 | if (SameDomainName(suffix, (const domainname*)"\x7" "in-addr" "\x4" "arpa" )) return mDNSAddrType_IPv4; |
| 2270 | if (SameDomainName(suffix, (const domainname*)"\x3" "ip6" "\x4" "arpa" )) return mDNSAddrType_IPv6; |
| 2271 | } |
| 2272 | return(mDNSAddrType_None); |
| 2273 | } |
| 2274 | |
| 2275 | mDNSlocal void SendARP(mDNS *const m, const mDNSu8 op, const AuthRecord *const rr, |
| 2276 | const mDNSv4Addr *const spa, const mDNSEthAddr *const tha, const mDNSv4Addr *const tpa, const mDNSEthAddr *const dst) |
| 2277 | { |
| 2278 | int i; |
| 2279 | mDNSu8 *ptr = m->omsg.data; |
| 2280 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); |
| 2281 | if (!intf) { LogMsg("SendARP: No interface with InterfaceID %p found %s" , rr->resrec.InterfaceID, ARDisplayString(m,rr)); return; } |
| 2282 | |
| 2283 | // 0x00 Destination address |
| 2284 | for (i=0; i<6; i++) *ptr++ = dst->b[i]; |
| 2285 | |
| 2286 | // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us) |
| 2287 | for (i=0; i<6; i++) *ptr++ = intf->MAC.b[0]; |
| 2288 | |
| 2289 | // 0x0C ARP Ethertype (0x0806) |
| 2290 | *ptr++ = 0x08; *ptr++ = 0x06; |
| 2291 | |
| 2292 | // 0x0E ARP header |
| 2293 | *ptr++ = 0x00; *ptr++ = 0x01; // Hardware address space; Ethernet = 1 |
| 2294 | *ptr++ = 0x08; *ptr++ = 0x00; // Protocol address space; IP = 0x0800 |
| 2295 | *ptr++ = 6; // Hardware address length |
| 2296 | *ptr++ = 4; // Protocol address length |
| 2297 | *ptr++ = 0x00; *ptr++ = op; // opcode; Request = 1, Response = 2 |
| 2298 | |
| 2299 | // 0x16 Sender hardware address (our MAC address) |
| 2300 | for (i=0; i<6; i++) *ptr++ = intf->MAC.b[i]; |
| 2301 | |
| 2302 | // 0x1C Sender protocol address |
| 2303 | for (i=0; i<4; i++) *ptr++ = spa->b[i]; |
| 2304 | |
| 2305 | // 0x20 Target hardware address |
| 2306 | for (i=0; i<6; i++) *ptr++ = tha->b[i]; |
| 2307 | |
| 2308 | // 0x26 Target protocol address |
| 2309 | for (i=0; i<4; i++) *ptr++ = tpa->b[i]; |
| 2310 | |
| 2311 | // 0x2A Total ARP Packet length 42 bytes |
| 2312 | mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID); |
| 2313 | } |
| 2314 | |
| 2315 | mDNSlocal mDNSu16 CheckSum(const void *const data, mDNSs32 length, mDNSu32 sum) |
| 2316 | { |
| 2317 | const mDNSu16 *ptr = data; |
| 2318 | while (length > 0) { length -= 2; sum += *ptr++; } |
| 2319 | sum = (sum & 0xFFFF) + (sum >> 16); |
| 2320 | sum = (sum & 0xFFFF) + (sum >> 16); |
| 2321 | return(sum != 0xFFFF ? sum : 0); |
| 2322 | } |
| 2323 | |
| 2324 | mDNSlocal mDNSu16 IPv6CheckSum(const mDNSv6Addr *const src, const mDNSv6Addr *const dst, const mDNSu8 protocol, const void *const data, const mDNSu32 length) |
| 2325 | { |
| 2326 | IPv6PseudoHeader ph; |
| 2327 | ph.src = *src; |
| 2328 | ph.dst = *dst; |
| 2329 | ph.len.b[0] = length >> 24; |
| 2330 | ph.len.b[1] = length >> 16; |
| 2331 | ph.len.b[2] = length >> 8; |
| 2332 | ph.len.b[3] = length; |
| 2333 | ph.pro.b[0] = 0; |
| 2334 | ph.pro.b[1] = 0; |
| 2335 | ph.pro.b[2] = 0; |
| 2336 | ph.pro.b[3] = protocol; |
| 2337 | return CheckSum(&ph, sizeof(ph), CheckSum(data, length, 0)); |
| 2338 | } |
| 2339 | |
| 2340 | mDNSlocal void SendNDP(mDNS *const m, const mDNSu8 op, const mDNSu8 flags, const AuthRecord *const rr, |
| 2341 | const mDNSv6Addr *const spa, const mDNSEthAddr *const tha, const mDNSv6Addr *const tpa, const mDNSEthAddr *const dst) |
| 2342 | { |
| 2343 | int i; |
| 2344 | mDNSOpaque16 checksum; |
| 2345 | mDNSu8 *ptr = m->omsg.data; |
| 2346 | // Some recipient hosts seem to ignore Neighbor Solicitations if the IPv6-layer destination address is not the |
| 2347 | // appropriate IPv6 solicited node multicast address, so we use that IPv6-layer destination address, even though |
| 2348 | // at the Ethernet-layer we unicast the packet to the intended target, to avoid wasting network bandwidth. |
| 2349 | const mDNSv6Addr mc = { { 0xFF,0x02,0x00,0x00, 0,0,0,0, 0,0,0,1, 0xFF,tpa->b[0xD],tpa->b[0xE],tpa->b[0xF] } }; |
| 2350 | const mDNSv6Addr *const v6dst = (op == NDP_Sol) ? &mc : tpa; |
| 2351 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, rr->resrec.InterfaceID); |
| 2352 | if (!intf) { LogMsg("SendNDP: No interface with InterfaceID %p found %s" , rr->resrec.InterfaceID, ARDisplayString(m,rr)); return; } |
| 2353 | |
| 2354 | // 0x00 Destination address |
| 2355 | for (i=0; i<6; i++) *ptr++ = dst->b[i]; |
| 2356 | // Right now we only send Neighbor Solicitations to verify whether the host we're proxying for has gone to sleep yet. |
| 2357 | // Since we know who we're looking for, we send it via Ethernet-layer unicast, rather than bothering every host on the |
| 2358 | // link with a pointless link-layer multicast. |
| 2359 | // Should we want to send traditional Neighbor Solicitations in the future, where we really don't know in advance what |
| 2360 | // Ethernet-layer address we're looking for, we'll need to send to the appropriate Ethernet-layer multicast address: |
| 2361 | // *ptr++ = 0x33; |
| 2362 | // *ptr++ = 0x33; |
| 2363 | // *ptr++ = 0xFF; |
| 2364 | // *ptr++ = tpa->b[0xD]; |
| 2365 | // *ptr++ = tpa->b[0xE]; |
| 2366 | // *ptr++ = tpa->b[0xF]; |
| 2367 | |
| 2368 | // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us) |
| 2369 | for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i]; |
| 2370 | |
| 2371 | // 0x0C IPv6 Ethertype (0x86DD) |
| 2372 | *ptr++ = 0x86; *ptr++ = 0xDD; |
| 2373 | |
| 2374 | // 0x0E IPv6 header |
| 2375 | *ptr++ = 0x60; *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00; // Version, Traffic Class, Flow Label |
| 2376 | *ptr++ = 0x00; *ptr++ = 0x20; // Length |
| 2377 | *ptr++ = 0x3A; // Protocol == ICMPv6 |
| 2378 | *ptr++ = 0xFF; // Hop Limit |
| 2379 | |
| 2380 | // 0x16 Sender IPv6 address |
| 2381 | for (i=0; i<16; i++) *ptr++ = spa->b[i]; |
| 2382 | |
| 2383 | // 0x26 Destination IPv6 address |
| 2384 | for (i=0; i<16; i++) *ptr++ = v6dst->b[i]; |
| 2385 | |
| 2386 | // 0x36 NDP header |
| 2387 | *ptr++ = op; // 0x87 == Neighbor Solicitation, 0x88 == Neighbor Advertisement |
| 2388 | *ptr++ = 0x00; // Code |
| 2389 | *ptr++ = 0x00; *ptr++ = 0x00; // Checksum placeholder (0x38, 0x39) |
| 2390 | *ptr++ = flags; |
| 2391 | *ptr++ = 0x00; *ptr++ = 0x00; *ptr++ = 0x00; |
| 2392 | |
| 2393 | if (op == NDP_Sol) // Neighbor Solicitation. The NDP "target" is the address we seek. |
| 2394 | { |
| 2395 | // 0x3E NDP target. |
| 2396 | for (i=0; i<16; i++) *ptr++ = tpa->b[i]; |
| 2397 | // 0x4E Source Link-layer Address |
| 2398 | // <http://www.ietf.org/rfc/rfc2461.txt> |
| 2399 | // MUST NOT be included when the source IP address is the unspecified address. |
| 2400 | // Otherwise, on link layers that have addresses this option MUST be included |
| 2401 | // in multicast solicitations and SHOULD be included in unicast solicitations. |
| 2402 | if (!mDNSIPv6AddressIsZero(*spa)) |
| 2403 | { |
| 2404 | *ptr++ = NDP_SrcLL; // Option Type 1 == Source Link-layer Address |
| 2405 | *ptr++ = 0x01; // Option length 1 (in units of 8 octets) |
| 2406 | for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i]; |
| 2407 | } |
| 2408 | } |
| 2409 | else // Neighbor Advertisement. The NDP "target" is the address we're giving information about. |
| 2410 | { |
| 2411 | // 0x3E NDP target. |
| 2412 | for (i=0; i<16; i++) *ptr++ = spa->b[i]; |
| 2413 | // 0x4E Target Link-layer Address |
| 2414 | *ptr++ = NDP_TgtLL; // Option Type 2 == Target Link-layer Address |
| 2415 | *ptr++ = 0x01; // Option length 1 (in units of 8 octets) |
| 2416 | for (i=0; i<6; i++) *ptr++ = (tha ? *tha : intf->MAC).b[i]; |
| 2417 | } |
| 2418 | |
| 2419 | // 0x4E or 0x56 Total NDP Packet length 78 or 86 bytes |
| 2420 | m->omsg.data[0x13] = ptr - &m->omsg.data[0x36]; // Compute actual length |
| 2421 | checksum.NotAnInteger = ~IPv6CheckSum(spa, v6dst, 0x3A, &m->omsg.data[0x36], m->omsg.data[0x13]); |
| 2422 | m->omsg.data[0x38] = checksum.b[0]; |
| 2423 | m->omsg.data[0x39] = checksum.b[1]; |
| 2424 | |
| 2425 | mDNSPlatformSendRawPacket(m->omsg.data, ptr, rr->resrec.InterfaceID); |
| 2426 | } |
| 2427 | |
| 2428 | mDNSlocal void SetupTracerOpt(const mDNS *const m, rdataOPT *const Trace) |
| 2429 | { |
| 2430 | mDNSu32 DNS_VERS = _DNS_SD_H; |
| 2431 | Trace->u.tracer.platf = m->mDNS_plat; |
| 2432 | Trace->u.tracer.mDNSv = DNS_VERS; |
| 2433 | |
| 2434 | Trace->opt = kDNSOpt_Trace; |
| 2435 | Trace->optlen = DNSOpt_TraceData_Space - 4; |
| 2436 | } |
| 2437 | |
| 2438 | mDNSlocal void SetupOwnerOpt(const mDNS *const m, const NetworkInterfaceInfo *const intf, rdataOPT *const owner) |
| 2439 | { |
| 2440 | owner->u.owner.vers = 0; |
| 2441 | owner->u.owner.seq = m->SleepSeqNum; |
| 2442 | owner->u.owner.HMAC = m->PrimaryMAC; |
| 2443 | owner->u.owner.IMAC = intf->MAC; |
| 2444 | owner->u.owner.password = zeroEthAddr; |
| 2445 | |
| 2446 | // Don't try to compute the optlen until *after* we've set up the data fields |
| 2447 | // Right now the DNSOpt_Owner_Space macro does not depend on the owner->u.owner being set up correctly, but in the future it might |
| 2448 | owner->opt = kDNSOpt_Owner; |
| 2449 | owner->optlen = DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) - 4; |
| 2450 | } |
| 2451 | |
| 2452 | mDNSlocal void GrantUpdateCredit(AuthRecord *rr) |
| 2453 | { |
| 2454 | if (++rr->UpdateCredits >= kMaxUpdateCredits) rr->NextUpdateCredit = 0; |
| 2455 | else rr->NextUpdateCredit = NonZeroTime(rr->NextUpdateCredit + kUpdateCreditRefreshInterval); |
| 2456 | } |
| 2457 | |
| 2458 | mDNSlocal mDNSBool ShouldSendGoodbyesBeforeSleep(mDNS *const m, const NetworkInterfaceInfo *intf, AuthRecord *rr) |
| 2459 | { |
| 2460 | // If there are no sleep proxies, we set the state to SleepState_Sleeping explicitly |
| 2461 | // and hence there is no need to check for Transfering state. But if we have sleep |
| 2462 | // proxies and partially sending goodbyes for some records, we will be in Transfering |
| 2463 | // state and hence need to make sure that we send goodbyes in that case too. Checking whether |
| 2464 | // we are not awake handles both cases. |
| 2465 | if ((rr->AuthFlags & AuthFlagsWakeOnly) && (m->SleepState != SleepState_Awake)) |
| 2466 | { |
| 2467 | debugf("ShouldSendGoodbyesBeforeSleep: marking for goodbye" , ARDisplayString(m, rr)); |
| 2468 | return mDNStrue; |
| 2469 | } |
| 2470 | |
| 2471 | if (m->SleepState != SleepState_Sleeping) |
| 2472 | return mDNSfalse; |
| 2473 | |
| 2474 | // If we are going to sleep and in SleepState_Sleeping, SendGoodbyes on the interface tell you |
| 2475 | // whether you can send goodbyes or not. |
| 2476 | if (!intf->SendGoodbyes) |
| 2477 | { |
| 2478 | debugf("ShouldSendGoodbyesBeforeSleep: not sending goodbye %s, int %p" , ARDisplayString(m, rr), intf->InterfaceID); |
| 2479 | return mDNSfalse; |
| 2480 | } |
| 2481 | else |
| 2482 | { |
| 2483 | debugf("ShouldSendGoodbyesBeforeSleep: sending goodbye %s, int %p" , ARDisplayString(m, rr), intf->InterfaceID); |
| 2484 | return mDNStrue; |
| 2485 | } |
| 2486 | } |
| 2487 | |
| 2488 | mDNSlocal mDNSBool IsInterfaceValidForAuthRecord(const AuthRecord *ar, mDNSInterfaceID InterfaceID) |
| 2489 | { |
| 2490 | mDNSBool result; |
| 2491 | |
| 2492 | if (ar->resrec.InterfaceID == mDNSInterface_Any) |
| 2493 | { |
| 2494 | result = mDNSPlatformValidRecordForInterface(ar, InterfaceID); |
| 2495 | } |
| 2496 | else |
| 2497 | { |
| 2498 | result = (ar->resrec.InterfaceID == InterfaceID); |
| 2499 | } |
| 2500 | |
| 2501 | return(result); |
| 2502 | } |
| 2503 | |
| 2504 | // Note about acceleration of announcements to facilitate automatic coalescing of |
| 2505 | // multiple independent threads of announcements into a single synchronized thread: |
| 2506 | // The announcements in the packet may be at different stages of maturity; |
| 2507 | // One-second interval, two-second interval, four-second interval, and so on. |
| 2508 | // After we've put in all the announcements that are due, we then consider |
| 2509 | // whether there are other nearly-due announcements that are worth accelerating. |
| 2510 | // To be eligible for acceleration, a record MUST NOT be older (further along |
| 2511 | // its timeline) than the most mature record we've already put in the packet. |
| 2512 | // In other words, younger records can have their timelines accelerated to catch up |
| 2513 | // with their elder bretheren; this narrows the age gap and helps them eventually get in sync. |
| 2514 | // Older records cannot have their timelines accelerated; this would just widen |
| 2515 | // the gap between them and their younger bretheren and get them even more out of sync. |
| 2516 | |
| 2517 | // Note: SendResponses calls mDNS_Deregister_internal which can call a user callback, which may change |
| 2518 | // the record list and/or question list. |
| 2519 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 2520 | mDNSlocal void SendResponses(mDNS *const m) |
| 2521 | { |
| 2522 | int pktcount = 0; |
| 2523 | AuthRecord *rr, *r2; |
| 2524 | mDNSs32 maxExistingAnnounceInterval = 0; |
| 2525 | const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces); |
| 2526 | |
| 2527 | m->NextScheduledResponse = m->timenow + FutureTime; |
| 2528 | |
| 2529 | if (m->SleepState == SleepState_Transferring) RetrySPSRegistrations(m); |
| 2530 | |
| 2531 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2532 | if (rr->ImmedUnicast) |
| 2533 | { |
| 2534 | mDNSAddr v4 = { mDNSAddrType_IPv4, {{{0}}} }; |
| 2535 | mDNSAddr v6 = { mDNSAddrType_IPv6, {{{0}}} }; |
| 2536 | v4.ip.v4 = rr->v4Requester; |
| 2537 | v6.ip.v6 = rr->v6Requester; |
| 2538 | if (!mDNSIPv4AddressIsZero(rr->v4Requester)) SendDelayedUnicastResponse(m, &v4, rr->ImmedAnswer); |
| 2539 | if (!mDNSIPv6AddressIsZero(rr->v6Requester)) SendDelayedUnicastResponse(m, &v6, rr->ImmedAnswer); |
| 2540 | if (rr->ImmedUnicast) |
| 2541 | { |
| 2542 | LogMsg("SendResponses: ERROR: rr->ImmedUnicast still set: %s" , ARDisplayString(m, rr)); |
| 2543 | rr->ImmedUnicast = mDNSfalse; |
| 2544 | } |
| 2545 | } |
| 2546 | |
| 2547 | // *** |
| 2548 | // *** 1. Setup: Set the SendRNow and ImmedAnswer fields to indicate which interface(s) the records need to be sent on |
| 2549 | // *** |
| 2550 | |
| 2551 | // Run through our list of records, and decide which ones we're going to announce on all interfaces |
| 2552 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2553 | { |
| 2554 | while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr); |
| 2555 | if (TimeToAnnounceThisRecord(rr, m->timenow)) |
| 2556 | { |
| 2557 | if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) |
| 2558 | { |
| 2559 | if (!rr->WakeUp.HMAC.l[0]) |
| 2560 | { |
| 2561 | if (rr->AnnounceCount) rr->ImmedAnswer = mDNSInterfaceMark; // Send goodbye packet on all interfaces |
| 2562 | } |
| 2563 | else |
| 2564 | { |
| 2565 | mDNSBool unicastOnly; |
| 2566 | LogSPS("SendResponses: Sending wakeup %2d for %.6a %s" , rr->AnnounceCount-3, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 2567 | unicastOnly = ((rr->AnnounceCount == WakeupCount) || (rr->AnnounceCount == WakeupCount - 1)) ? mDNStrue : mDNSfalse; |
| 2568 | SendWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.IMAC, &rr->WakeUp.password, unicastOnly); |
| 2569 | for (r2 = rr; r2; r2=r2->next) |
| 2570 | if ((r2->resrec.RecordType == kDNSRecordTypeDeregistering) && r2->AnnounceCount && (r2->resrec.InterfaceID == rr->resrec.InterfaceID) && |
| 2571 | mDNSSameEthAddress(&r2->WakeUp.IMAC, &rr->WakeUp.IMAC) && !mDNSSameEthAddress(&zeroEthAddr, &r2->WakeUp.HMAC)) |
| 2572 | { |
| 2573 | // For now we only want to send a single Unsolicited Neighbor Advertisement restoring the address to the original |
| 2574 | // owner, because these packets can cause some IPv6 stacks to falsely conclude that there's an address conflict. |
| 2575 | if (r2->AddressProxy.type == mDNSAddrType_IPv6 && r2->AnnounceCount == WakeupCount) |
| 2576 | { |
| 2577 | LogSPS("NDP Announcement %2d Releasing traffic for H-MAC %.6a I-MAC %.6a %s" , |
| 2578 | r2->AnnounceCount-3, &r2->WakeUp.HMAC, &r2->WakeUp.IMAC, ARDisplayString(m,r2)); |
| 2579 | SendNDP(m, NDP_Adv, NDP_Override, r2, &r2->AddressProxy.ip.v6, &r2->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth); |
| 2580 | } |
| 2581 | r2->LastAPTime = m->timenow; |
| 2582 | // After 15 wakeups without success (maybe host has left the network) send three goodbyes instead |
| 2583 | if (--r2->AnnounceCount <= GoodbyeCount) r2->WakeUp.HMAC = zeroEthAddr; |
| 2584 | } |
| 2585 | } |
| 2586 | } |
| 2587 | else if (ResourceRecordIsValidAnswer(rr)) |
| 2588 | { |
| 2589 | if (rr->AddressProxy.type) |
| 2590 | { |
| 2591 | if (!mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC)) |
| 2592 | { |
| 2593 | rr->AnnounceCount--; |
| 2594 | rr->ThisAPInterval *= 2; |
| 2595 | rr->LastAPTime = m->timenow; |
| 2596 | if (rr->AddressProxy.type == mDNSAddrType_IPv4) |
| 2597 | { |
| 2598 | LogSPS("ARP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s" , |
| 2599 | rr->AnnounceCount, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); |
| 2600 | SendARP(m, 1, rr, &rr->AddressProxy.ip.v4, &zeroEthAddr, &rr->AddressProxy.ip.v4, &onesEthAddr); |
| 2601 | } |
| 2602 | else if (rr->AddressProxy.type == mDNSAddrType_IPv6) |
| 2603 | { |
| 2604 | LogSPS("NDP Announcement %2d Capturing traffic for H-MAC %.6a I-MAC %.6a %s" , |
| 2605 | rr->AnnounceCount, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); |
| 2606 | SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, mDNSNULL, &AllHosts_v6, &AllHosts_v6_Eth); |
| 2607 | } |
| 2608 | } |
| 2609 | } |
| 2610 | else |
| 2611 | { |
| 2612 | rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces |
| 2613 | if (maxExistingAnnounceInterval < rr->ThisAPInterval) |
| 2614 | maxExistingAnnounceInterval = rr->ThisAPInterval; |
| 2615 | if (rr->UpdateBlocked) rr->UpdateBlocked = 0; |
| 2616 | } |
| 2617 | } |
| 2618 | } |
| 2619 | } |
| 2620 | |
| 2621 | // Any interface-specific records we're going to send are marked as being sent on all appropriate interfaces (which is just one) |
| 2622 | // Eligible records that are more than half-way to their announcement time are accelerated |
| 2623 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2624 | if ((rr->resrec.InterfaceID && rr->ImmedAnswer) || |
| 2625 | (rr->ThisAPInterval <= maxExistingAnnounceInterval && |
| 2626 | TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2) && |
| 2627 | !rr->AddressProxy.type && // Don't include ARP Annoucements when considering which records to accelerate |
| 2628 | ResourceRecordIsValidAnswer(rr))) |
| 2629 | rr->ImmedAnswer = mDNSInterfaceMark; // Send on all interfaces |
| 2630 | |
| 2631 | // When sending SRV records (particularly when announcing a new service) automatically add related Address record(s) as additionals |
| 2632 | // Note: Currently all address records are interface-specific, so it's safe to set ImmedAdditional to their InterfaceID, |
| 2633 | // which will be non-null. If by some chance there is an address record that's not interface-specific (should never happen) |
| 2634 | // then all that means is that it won't get sent -- which would not be the end of the world. |
| 2635 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2636 | { |
| 2637 | if (rr->ImmedAnswer && rr->resrec.rrtype == kDNSType_SRV) |
| 2638 | for (r2=m->ResourceRecords; r2; r2=r2->next) // Scan list of resource records |
| 2639 | if (RRTypeIsAddressType(r2->resrec.rrtype) && // For all address records (A/AAAA) ... |
| 2640 | ResourceRecordIsValidAnswer(r2) && // ... which are valid for answer ... |
| 2641 | rr->LastMCTime - r2->LastMCTime >= 0 && // ... which we have not sent recently ... |
| 2642 | rr->resrec.rdatahash == r2->resrec.namehash && // ... whose name is the name of the SRV target |
| 2643 | SameDomainName(&rr->resrec.rdata->u.srv.target, r2->resrec.name) && |
| 2644 | (rr->ImmedAnswer == mDNSInterfaceMark || rr->ImmedAnswer == r2->resrec.InterfaceID)) |
| 2645 | r2->ImmedAdditional = r2->resrec.InterfaceID; // ... then mark this address record for sending too |
| 2646 | // We also make sure we send the DeviceInfo TXT record too, if necessary |
| 2647 | // We check for RecordType == kDNSRecordTypeShared because we don't want to tag the |
| 2648 | // DeviceInfo TXT record onto a goodbye packet (RecordType == kDNSRecordTypeDeregistering). |
| 2649 | if (rr->ImmedAnswer && rr->resrec.RecordType == kDNSRecordTypeShared && rr->resrec.rrtype == kDNSType_PTR) |
| 2650 | if (ResourceRecordIsValidAnswer(&m->DeviceInfo) && SameDomainLabel(rr->resrec.rdata->u.name.c, m->DeviceInfo.resrec.name->c)) |
| 2651 | { |
| 2652 | if (!m->DeviceInfo.ImmedAnswer) m->DeviceInfo.ImmedAnswer = rr->ImmedAnswer; |
| 2653 | else m->DeviceInfo.ImmedAnswer = mDNSInterfaceMark; |
| 2654 | } |
| 2655 | } |
| 2656 | |
| 2657 | // If there's a record which is supposed to be unique that we're going to send, then make sure that we give |
| 2658 | // the whole RRSet as an atomic unit. That means that if we have any other records with the same name/type/class |
| 2659 | // then we need to mark them for sending too. Otherwise, if we set the kDNSClass_UniqueRRSet bit on a |
| 2660 | // record, then other RRSet members that have not been sent recently will get flushed out of client caches. |
| 2661 | // -- If a record is marked to be sent on a certain interface, make sure the whole set is marked to be sent on that interface |
| 2662 | // -- If any record is marked to be sent on all interfaces, make sure the whole set is marked to be sent on all interfaces |
| 2663 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2664 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 2665 | { |
| 2666 | if (rr->ImmedAnswer) // If we're sending this as answer, see that its whole RRSet is similarly marked |
| 2667 | { |
| 2668 | for (r2 = m->ResourceRecords; r2; r2=r2->next) |
| 2669 | { |
| 2670 | if ((r2->resrec.RecordType & kDNSRecordTypeUniqueMask) && ResourceRecordIsValidAnswer(r2) && |
| 2671 | (r2->ImmedAnswer != mDNSInterfaceMark) && (r2->ImmedAnswer != rr->ImmedAnswer) && |
| 2672 | SameResourceRecordSignature(r2, rr) && |
| 2673 | ((rr->ImmedAnswer == mDNSInterfaceMark) || IsInterfaceValidForAuthRecord(r2, rr->ImmedAnswer))) |
| 2674 | { |
| 2675 | r2->ImmedAnswer = !r2->ImmedAnswer ? rr->ImmedAnswer : mDNSInterfaceMark; |
| 2676 | } |
| 2677 | } |
| 2678 | } |
| 2679 | else if (rr->ImmedAdditional) // If we're sending this as additional, see that its whole RRSet is similarly marked |
| 2680 | { |
| 2681 | for (r2 = m->ResourceRecords; r2; r2=r2->next) |
| 2682 | { |
| 2683 | if ((r2->resrec.RecordType & kDNSRecordTypeUniqueMask) && ResourceRecordIsValidAnswer(r2) && |
| 2684 | (r2->ImmedAdditional != rr->ImmedAdditional) && |
| 2685 | SameResourceRecordSignature(r2, rr) && |
| 2686 | IsInterfaceValidForAuthRecord(r2, rr->ImmedAdditional)) |
| 2687 | { |
| 2688 | r2->ImmedAdditional = rr->ImmedAdditional; |
| 2689 | } |
| 2690 | } |
| 2691 | } |
| 2692 | } |
| 2693 | |
| 2694 | // Now set SendRNow state appropriately |
| 2695 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2696 | { |
| 2697 | if (rr->ImmedAnswer == mDNSInterfaceMark) // Sending this record on all appropriate interfaces |
| 2698 | { |
| 2699 | rr->SendRNow = !intf ? mDNSNULL : (rr->resrec.InterfaceID) ? rr->resrec.InterfaceID : intf->InterfaceID; |
| 2700 | rr->ImmedAdditional = mDNSNULL; // No need to send as additional if sending as answer |
| 2701 | rr->LastMCTime = m->timenow; |
| 2702 | rr->LastMCInterface = rr->ImmedAnswer; |
| 2703 | rr->ProbeRestartCount = 0; // Reset the probe restart count |
| 2704 | // If we're announcing this record, and it's at least half-way to its ordained time, then consider this announcement done |
| 2705 | if (TimeToAnnounceThisRecord(rr, m->timenow + rr->ThisAPInterval/2)) |
| 2706 | { |
| 2707 | rr->AnnounceCount--; |
| 2708 | if (rr->resrec.RecordType != kDNSRecordTypeDeregistering) |
| 2709 | rr->ThisAPInterval *= 2; |
| 2710 | rr->LastAPTime = m->timenow; |
| 2711 | debugf("Announcing %##s (%s) %d" , rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), rr->AnnounceCount); |
| 2712 | } |
| 2713 | } |
| 2714 | else if (rr->ImmedAnswer) // Else, just respond to a single query on single interface: |
| 2715 | { |
| 2716 | rr->SendRNow = rr->ImmedAnswer; // Just respond on that interface |
| 2717 | rr->ImmedAdditional = mDNSNULL; // No need to send as additional too |
| 2718 | rr->LastMCTime = m->timenow; |
| 2719 | rr->LastMCInterface = rr->ImmedAnswer; |
| 2720 | } |
| 2721 | SetNextAnnounceProbeTime(m, rr); |
| 2722 | //if (rr->SendRNow) LogMsg("%-15.4a %s", &rr->v4Requester, ARDisplayString(m, rr)); |
| 2723 | } |
| 2724 | |
| 2725 | // *** |
| 2726 | // *** 2. Loop through interface list, sending records as appropriate |
| 2727 | // *** |
| 2728 | |
| 2729 | while (intf) |
| 2730 | { |
| 2731 | int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0; |
| 2732 | int TraceRecordSpace = (mDNS_McastTracingEnabled && MDNS_TRACER) ? DNSOpt_Header_Space + DNSOpt_TraceData_Space : 0; |
| 2733 | int numDereg = 0; |
| 2734 | int numAnnounce = 0; |
| 2735 | int numAnswer = 0; |
| 2736 | int AnoninfoSpace = 0; |
| 2737 | mDNSu8 *responseptr = m->omsg.data; |
| 2738 | mDNSu8 *newptr; |
| 2739 | InitializeDNSMessage(&m->omsg.h, zeroID, ResponseFlags); |
| 2740 | |
| 2741 | // First Pass. Look for: |
| 2742 | // 1. Deregistering records that need to send their goodbye packet |
| 2743 | // 2. Updated records that need to retract their old data |
| 2744 | // 3. Answers and announcements we need to send |
| 2745 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2746 | { |
| 2747 | |
| 2748 | // Skip this interface if the record InterfaceID is *Any and the record is not |
| 2749 | // appropriate for the interface type. |
| 2750 | if ((rr->SendRNow == intf->InterfaceID) && |
| 2751 | ((rr->resrec.InterfaceID == mDNSInterface_Any) && !mDNSPlatformValidRecordForInterface(rr, intf->InterfaceID))) |
| 2752 | { |
| 2753 | rr->SendRNow = GetNextActiveInterfaceID(intf); |
| 2754 | } |
| 2755 | else if (rr->SendRNow == intf->InterfaceID) |
| 2756 | { |
| 2757 | RData *OldRData = rr->resrec.rdata; |
| 2758 | mDNSu16 oldrdlength = rr->resrec.rdlength; |
| 2759 | mDNSu8 active = (mDNSu8) |
| 2760 | (rr->resrec.RecordType != kDNSRecordTypeDeregistering && !ShouldSendGoodbyesBeforeSleep(m, intf, rr)); |
| 2761 | newptr = mDNSNULL; |
| 2762 | if (rr->NewRData && active) |
| 2763 | { |
| 2764 | // See if we should send a courtesy "goodbye" for the old data before we replace it. |
| 2765 | if (ResourceRecordIsValidAnswer(rr) && rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) |
| 2766 | { |
| 2767 | newptr = PutRR_OS_TTL(responseptr, &m->omsg.h.numAnswers, &rr->resrec, 0); |
| 2768 | if (newptr) { responseptr = newptr; numDereg++; rr->RequireGoodbye = mDNSfalse; } |
| 2769 | else continue; // If this packet is already too full to hold the goodbye for this record, skip it for now and we'll retry later |
| 2770 | } |
| 2771 | SetNewRData(&rr->resrec, rr->NewRData, rr->newrdlength); |
| 2772 | } |
| 2773 | |
| 2774 | if (rr->resrec.AnonInfo) |
| 2775 | { |
| 2776 | int tmp = AnonInfoSpace(rr->resrec.AnonInfo); |
| 2777 | |
| 2778 | AnoninfoSpace += tmp; |
| 2779 | // Adjust OwnerRecordSpace/TraceRecordSpace which is used by PutRR_OS_TTL below so that |
| 2780 | // we have space to put in the NSEC3 record in the authority section. |
| 2781 | OwnerRecordSpace += tmp; |
| 2782 | TraceRecordSpace += tmp; |
| 2783 | } |
| 2784 | |
| 2785 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 2786 | rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it |
| 2787 | newptr = PutRR_OS_TTL(responseptr, &m->omsg.h.numAnswers, &rr->resrec, active ? rr->resrec.rroriginalttl : 0); |
| 2788 | rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state |
| 2789 | if (newptr) |
| 2790 | { |
| 2791 | responseptr = newptr; |
| 2792 | rr->RequireGoodbye = active; |
| 2793 | if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) numDereg++; |
| 2794 | else if (rr->LastAPTime == m->timenow) numAnnounce++;else numAnswer++; |
| 2795 | } |
| 2796 | |
| 2797 | if (rr->NewRData && active) |
| 2798 | SetNewRData(&rr->resrec, OldRData, oldrdlength); |
| 2799 | |
| 2800 | // The first time through (pktcount==0), if this record is verified unique |
| 2801 | // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too. |
| 2802 | if (!pktcount && active && (rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && !rr->SendNSECNow) |
| 2803 | rr->SendNSECNow = mDNSInterfaceMark; |
| 2804 | |
| 2805 | if (newptr) // If succeeded in sending, advance to next interface |
| 2806 | { |
| 2807 | if (rr->resrec.AnonInfo) |
| 2808 | { |
| 2809 | debugf("SendResponses: Marking %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p" , ARDisplayString(m, rr), OwnerRecordSpace, |
| 2810 | TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace); |
| 2811 | rr->resrec.AnonInfo->SendNow = intf->InterfaceID; |
| 2812 | } |
| 2813 | |
| 2814 | // If sending on all interfaces, go to next interface; else we're finished now |
| 2815 | if (rr->ImmedAnswer == mDNSInterfaceMark && rr->resrec.InterfaceID == mDNSInterface_Any) |
| 2816 | rr->SendRNow = GetNextActiveInterfaceID(intf); |
| 2817 | else |
| 2818 | rr->SendRNow = mDNSNULL; |
| 2819 | } |
| 2820 | } |
| 2821 | } |
| 2822 | |
| 2823 | // Get the reserved space back |
| 2824 | OwnerRecordSpace -= AnoninfoSpace; |
| 2825 | TraceRecordSpace -= AnoninfoSpace; |
| 2826 | newptr = responseptr; |
| 2827 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2828 | { |
| 2829 | if (rr->resrec.AnonInfo && rr->resrec.AnonInfo->SendNow == intf->InterfaceID) |
| 2830 | { |
| 2831 | ResourceRecord *nsec3RR = rr->resrec.AnonInfo->nsec3RR; |
| 2832 | |
| 2833 | newptr = PutRR_OS_TTL(newptr, &m->omsg.h.numAuthorities, nsec3RR, nsec3RR->rroriginalttl); |
| 2834 | if (newptr) |
| 2835 | { |
| 2836 | responseptr = newptr; |
| 2837 | debugf("SendResponses: Added NSEC3 %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p" , ARDisplayString(m, rr), OwnerRecordSpace, |
| 2838 | TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace); |
| 2839 | } |
| 2840 | else |
| 2841 | { |
| 2842 | LogMsg("SendResponses: Cannot add NSEC3 %s, OwnerRecordSpace %d, TraceRecordSpace %d, limit %p" , ARDisplayString(m, rr), OwnerRecordSpace, |
| 2843 | TraceRecordSpace, m->omsg.data + AllowedRRSpace(&m->omsg) - OwnerRecordSpace - TraceRecordSpace); |
| 2844 | } |
| 2845 | rr->resrec.AnonInfo->SendNow = mDNSNULL; |
| 2846 | } |
| 2847 | } |
| 2848 | // Second Pass. Add additional records, if there's space. |
| 2849 | newptr = responseptr; |
| 2850 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2851 | if (rr->ImmedAdditional == intf->InterfaceID) |
| 2852 | if (ResourceRecordIsValidAnswer(rr)) |
| 2853 | { |
| 2854 | // If we have at least one answer already in the packet, then plan to add additionals too |
| 2855 | mDNSBool SendAdditional = (m->omsg.h.numAnswers > 0); |
| 2856 | |
| 2857 | // If we're not planning to send any additionals, but this record is a unique one, then |
| 2858 | // make sure we haven't already sent any other members of its RRSet -- if we have, then they |
| 2859 | // will have had the cache flush bit set, so now we need to finish the job and send the rest. |
| 2860 | if (!SendAdditional && (rr->resrec.RecordType & kDNSRecordTypeUniqueMask)) |
| 2861 | { |
| 2862 | const AuthRecord *a; |
| 2863 | for (a = m->ResourceRecords; a; a=a->next) |
| 2864 | if (a->LastMCTime == m->timenow && |
| 2865 | a->LastMCInterface == intf->InterfaceID && |
| 2866 | SameResourceRecordSignature(a, rr)) { SendAdditional = mDNStrue; break; } |
| 2867 | } |
| 2868 | if (!SendAdditional) // If we don't want to send this after all, |
| 2869 | rr->ImmedAdditional = mDNSNULL; // then cancel its ImmedAdditional field |
| 2870 | else if (newptr) // Else, try to add it if we can |
| 2871 | { |
| 2872 | // The first time through (pktcount==0), if this record is verified unique |
| 2873 | // (i.e. typically A, AAAA, SRV, TXT and reverse-mapping PTR), set the flag to add an NSEC too. |
| 2874 | if (!pktcount && (rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && !rr->SendNSECNow) |
| 2875 | rr->SendNSECNow = mDNSInterfaceMark; |
| 2876 | |
| 2877 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 2878 | rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the cache flush bit so PutResourceRecord will set it |
| 2879 | newptr = PutRR_OS(newptr, &m->omsg.h.numAdditionals, &rr->resrec); |
| 2880 | rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear cache flush bit back to normal state |
| 2881 | if (newptr) |
| 2882 | { |
| 2883 | responseptr = newptr; |
| 2884 | rr->ImmedAdditional = mDNSNULL; |
| 2885 | rr->RequireGoodbye = mDNStrue; |
| 2886 | // If we successfully put this additional record in the packet, we record LastMCTime & LastMCInterface. |
| 2887 | // This matters particularly in the case where we have more than one IPv6 (or IPv4) address, because otherwise, |
| 2888 | // when we see our own multicast with the cache flush bit set, if we haven't set LastMCTime, then we'll get |
| 2889 | // all concerned and re-announce our record again to make sure it doesn't get flushed from peer caches. |
| 2890 | rr->LastMCTime = m->timenow; |
| 2891 | rr->LastMCInterface = intf->InterfaceID; |
| 2892 | } |
| 2893 | } |
| 2894 | } |
| 2895 | |
| 2896 | // Third Pass. Add NSEC records, if there's space. |
| 2897 | // When we're generating an NSEC record in response to a specify query for that type |
| 2898 | // (recognized by rr->SendNSECNow == intf->InterfaceID) we should really put the NSEC in the Answer Section, |
| 2899 | // not Additional Section, but for now it's easier to handle both cases in this Additional Section loop here. |
| 2900 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 2901 | if (rr->SendNSECNow == mDNSInterfaceMark || rr->SendNSECNow == intf->InterfaceID) |
| 2902 | { |
| 2903 | AuthRecord nsec; |
| 2904 | mDNSu8 *ptr; |
| 2905 | int len; |
| 2906 | mDNS_SetupResourceRecord(&nsec, mDNSNULL, mDNSInterface_Any, kDNSType_NSEC, rr->resrec.rroriginalttl, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 2907 | nsec.resrec.rrclass |= kDNSClass_UniqueRRSet; |
| 2908 | AssignDomainName(&nsec.namestorage, rr->resrec.name); |
| 2909 | ptr = nsec.rdatastorage.u.data; |
| 2910 | len = DomainNameLength(rr->resrec.name); |
| 2911 | // We have a nxt name followed by window number, window length and a window bitmap |
| 2912 | nsec.resrec.rdlength = len + 2 + NSEC_MCAST_WINDOW_SIZE; |
| 2913 | if (nsec.resrec.rdlength <= StandardAuthRDSize) |
| 2914 | { |
| 2915 | mDNSPlatformMemZero(ptr, nsec.resrec.rdlength); |
| 2916 | AssignDomainName((domainname *)ptr, rr->resrec.name); |
| 2917 | ptr += len; |
| 2918 | *ptr++ = 0; // window number |
| 2919 | *ptr++ = NSEC_MCAST_WINDOW_SIZE; // window length |
| 2920 | for (r2 = m->ResourceRecords; r2; r2=r2->next) |
| 2921 | if (ResourceRecordIsValidAnswer(r2) && SameResourceRecordNameClassInterface(r2, rr)) |
| 2922 | { |
| 2923 | if (r2->resrec.rrtype >= kDNSQType_ANY) { LogMsg("SendResponses: Can't create NSEC for record %s" , ARDisplayString(m, r2)); break; } |
| 2924 | else ptr[r2->resrec.rrtype >> 3] |= 128 >> (r2->resrec.rrtype & 7); |
| 2925 | } |
| 2926 | newptr = responseptr; |
| 2927 | if (!r2) // If we successfully built our NSEC record, add it to the packet now |
| 2928 | { |
| 2929 | newptr = PutRR_OS(responseptr, &m->omsg.h.numAdditionals, &nsec.resrec); |
| 2930 | if (newptr) responseptr = newptr; |
| 2931 | } |
| 2932 | } |
| 2933 | else LogMsg("SendResponses: not enough space (%d) in authrecord for nsec" , nsec.resrec.rdlength); |
| 2934 | |
| 2935 | // If we successfully put the NSEC record, clear the SendNSECNow flag |
| 2936 | // If we consider this NSEC optional, then we unconditionally clear the SendNSECNow flag, even if we fail to put this additional record |
| 2937 | if (newptr || rr->SendNSECNow == mDNSInterfaceMark) |
| 2938 | { |
| 2939 | rr->SendNSECNow = mDNSNULL; |
| 2940 | // Run through remainder of list clearing SendNSECNow flag for all other records which would generate the same NSEC |
| 2941 | for (r2 = rr->next; r2; r2=r2->next) |
| 2942 | if (SameResourceRecordNameClassInterface(r2, rr)) |
| 2943 | if (r2->SendNSECNow == mDNSInterfaceMark || r2->SendNSECNow == intf->InterfaceID) |
| 2944 | r2->SendNSECNow = mDNSNULL; |
| 2945 | } |
| 2946 | } |
| 2947 | |
| 2948 | if (m->omsg.h.numAnswers || m->omsg.h.numAdditionals) |
| 2949 | { |
| 2950 | // If we have data to send, add OWNER/TRACER/OWNER+TRACER option if necessary, then send packet |
| 2951 | if (OwnerRecordSpace || TraceRecordSpace) |
| 2952 | { |
| 2953 | AuthRecord opt; |
| 2954 | mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 2955 | opt.resrec.rrclass = NormalMaxDNSMessageData; |
| 2956 | opt.resrec.rdlength = sizeof(rdataOPT); |
| 2957 | opt.resrec.rdestimate = sizeof(rdataOPT); |
| 2958 | if (OwnerRecordSpace && TraceRecordSpace) |
| 2959 | { |
| 2960 | opt.resrec.rdlength += sizeof(rdataOPT); // Two options in this OPT record |
| 2961 | opt.resrec.rdestimate += sizeof(rdataOPT); |
| 2962 | SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); |
| 2963 | SetupTracerOpt(m, &opt.resrec.rdata->u.opt[1]); |
| 2964 | } |
| 2965 | else if (OwnerRecordSpace) |
| 2966 | { |
| 2967 | SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); |
| 2968 | } |
| 2969 | else if (TraceRecordSpace) |
| 2970 | { |
| 2971 | SetupTracerOpt(m, &opt.resrec.rdata->u.opt[0]); |
| 2972 | } |
| 2973 | newptr = PutResourceRecord(&m->omsg, responseptr, &m->omsg.h.numAdditionals, &opt.resrec); |
| 2974 | if (newptr) |
| 2975 | { |
| 2976 | responseptr = newptr; |
| 2977 | } |
| 2978 | else if (m->omsg.h.numAnswers + m->omsg.h.numAuthorities + m->omsg.h.numAdditionals == 1) |
| 2979 | { |
| 2980 | LogInfo("SendResponses: No space in packet for %s %s OPT record (%d/%d/%d/%d) %s" , OwnerRecordSpace ? "OWNER" : "" , TraceRecordSpace ? "TRACER" : "" , |
| 2981 | m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); |
| 2982 | } |
| 2983 | else |
| 2984 | { |
| 2985 | LogMsg("SendResponses: How did we fail to have space for %s %s OPT record (%d/%d/%d/%d) %s" , OwnerRecordSpace ? "OWNER" : "" , TraceRecordSpace ? "TRACER" : "" , |
| 2986 | m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); |
| 2987 | } |
| 2988 | } |
| 2989 | |
| 2990 | debugf("SendResponses: Sending %d Deregistration%s, %d Announcement%s, %d Answer%s, %d Additional%s on %p" , |
| 2991 | numDereg, numDereg == 1 ? "" : "s" , |
| 2992 | numAnnounce, numAnnounce == 1 ? "" : "s" , |
| 2993 | numAnswer, numAnswer == 1 ? "" : "s" , |
| 2994 | m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s" , intf->InterfaceID); |
| 2995 | |
| 2996 | if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse); |
| 2997 | if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, responseptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL, mDNSfalse); |
| 2998 | if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10); |
| 2999 | if (++pktcount >= 1000) { LogMsg("SendResponses exceeded loop limit %d: giving up" , pktcount); break; } |
| 3000 | // There might be more things to send on this interface, so go around one more time and try again. |
| 3001 | } |
| 3002 | else // Nothing more to send on this interface; go to next |
| 3003 | { |
| 3004 | const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next); |
| 3005 | #if MDNS_DEBUGMSGS && 0 |
| 3006 | const char *const msg = next ? "SendResponses: Nothing more on %p; moving to %p" : "SendResponses: Nothing more on %p" ; |
| 3007 | debugf(msg, intf, next); |
| 3008 | #endif |
| 3009 | intf = next; |
| 3010 | pktcount = 0; // When we move to a new interface, reset packet count back to zero -- NSEC generation logic uses it |
| 3011 | } |
| 3012 | } |
| 3013 | |
| 3014 | // *** |
| 3015 | // *** 3. Cleanup: Now that everything is sent, call client callback functions, and reset state variables |
| 3016 | // *** |
| 3017 | |
| 3018 | if (m->CurrentRecord) |
| 3019 | LogMsg("SendResponses ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 3020 | m->CurrentRecord = m->ResourceRecords; |
| 3021 | while (m->CurrentRecord) |
| 3022 | { |
| 3023 | rr = m->CurrentRecord; |
| 3024 | m->CurrentRecord = rr->next; |
| 3025 | |
| 3026 | if (rr->SendRNow) |
| 3027 | { |
| 3028 | if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P) |
| 3029 | LogInfo("SendResponses: No active interface %d to send: %d %02X %s" , |
| 3030 | IID(rr->SendRNow), IID(rr->resrec.InterfaceID), rr->resrec.RecordType, ARDisplayString(m, rr)); |
| 3031 | rr->SendRNow = mDNSNULL; |
| 3032 | } |
| 3033 | |
| 3034 | if (rr->ImmedAnswer || rr->resrec.RecordType == kDNSRecordTypeDeregistering) |
| 3035 | { |
| 3036 | if (rr->NewRData) CompleteRDataUpdate(m, rr); // Update our rdata, clear the NewRData pointer, and return memory to the client |
| 3037 | |
| 3038 | if (rr->resrec.RecordType == kDNSRecordTypeDeregistering && rr->AnnounceCount == 0) |
| 3039 | { |
| 3040 | // For Unicast, when we get the response from the server, we will call CompleteDeregistration |
| 3041 | if (!AuthRecord_uDNS(rr)) CompleteDeregistration(m, rr); // Don't touch rr after this |
| 3042 | } |
| 3043 | else |
| 3044 | { |
| 3045 | rr->ImmedAnswer = mDNSNULL; |
| 3046 | rr->ImmedUnicast = mDNSfalse; |
| 3047 | rr->v4Requester = zerov4Addr; |
| 3048 | rr->v6Requester = zerov6Addr; |
| 3049 | } |
| 3050 | } |
| 3051 | } |
| 3052 | verbosedebugf("SendResponses: Next in %ld ticks" , m->NextScheduledResponse - m->timenow); |
| 3053 | } |
| 3054 | |
| 3055 | // Calling CheckCacheExpiration() is an expensive operation because it has to look at the entire cache, |
| 3056 | // so we want to be lazy about how frequently we do it. |
| 3057 | // 1. If a cache record is currently referenced by *no* active questions, |
| 3058 | // then we don't mind expiring it up to a minute late (who will know?) |
| 3059 | // 2. Else, if a cache record is due for some of its final expiration queries, |
| 3060 | // we'll allow them to be late by up to 2% of the TTL |
| 3061 | // 3. Else, if a cache record has completed all its final expiration queries without success, |
| 3062 | // and is expiring, and had an original TTL more than ten seconds, we'll allow it to be one second late |
| 3063 | // 4. Else, it is expiring and had an original TTL of ten seconds or less (includes explicit goodbye packets), |
| 3064 | // so allow at most 1/10 second lateness |
| 3065 | // 5. For records with rroriginalttl set to zero, that means we really want to delete them immediately |
| 3066 | // (we have a new record with DelayDelivery set, waiting for the old record to go away before we can notify clients). |
| 3067 | #define CacheCheckGracePeriod(RR) ( \ |
| 3068 | ((RR)->CRActiveQuestion == mDNSNULL ) ? (60 * mDNSPlatformOneSecond) : \ |
| 3069 | ((RR)->UnansweredQueries < MaxUnansweredQueries) ? (TicksTTL(rr)/50) : \ |
| 3070 | ((RR)->resrec.rroriginalttl > 10 ) ? (mDNSPlatformOneSecond) : \ |
| 3071 | ((RR)->resrec.rroriginalttl > 0 ) ? (mDNSPlatformOneSecond/10) : 0) |
| 3072 | |
| 3073 | #define NextCacheCheckEvent(RR) ((RR)->NextRequiredQuery + CacheCheckGracePeriod(RR)) |
| 3074 | |
| 3075 | mDNSexport void ScheduleNextCacheCheckTime(mDNS *const m, const mDNSu32 slot, const mDNSs32 event) |
| 3076 | { |
| 3077 | if (m->rrcache_nextcheck[slot] - event > 0) |
| 3078 | m->rrcache_nextcheck[slot] = event; |
| 3079 | if (m->NextCacheCheck - event > 0) |
| 3080 | m->NextCacheCheck = event; |
| 3081 | } |
| 3082 | |
| 3083 | // Note: MUST call SetNextCacheCheckTimeForRecord any time we change: |
| 3084 | // rr->TimeRcvd |
| 3085 | // rr->resrec.rroriginalttl |
| 3086 | // rr->UnansweredQueries |
| 3087 | // rr->CRActiveQuestion |
| 3088 | mDNSexport void SetNextCacheCheckTimeForRecord(mDNS *const m, CacheRecord *const rr) |
| 3089 | { |
| 3090 | rr->NextRequiredQuery = RRExpireTime(rr); |
| 3091 | |
| 3092 | // If we have an active question, then see if we want to schedule a refresher query for this record. |
| 3093 | // Usually we expect to do four queries, at 80-82%, 85-87%, 90-92% and then 95-97% of the TTL. |
| 3094 | if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries) |
| 3095 | { |
| 3096 | rr->NextRequiredQuery -= TicksTTL(rr)/20 * (MaxUnansweredQueries - rr->UnansweredQueries); |
| 3097 | rr->NextRequiredQuery += mDNSRandom((mDNSu32)TicksTTL(rr)/50); |
| 3098 | verbosedebugf("SetNextCacheCheckTimeForRecord: NextRequiredQuery in %ld sec CacheCheckGracePeriod %d ticks for %s" , |
| 3099 | (rr->NextRequiredQuery - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m,rr)); |
| 3100 | } |
| 3101 | ScheduleNextCacheCheckTime(m, HashSlotFromNameHash(rr->resrec.namehash), NextCacheCheckEvent(rr)); |
| 3102 | } |
| 3103 | |
| 3104 | #define kMinimumReconfirmTime ((mDNSu32)mDNSPlatformOneSecond * 5) |
| 3105 | #define kDefaultReconfirmTimeForWake ((mDNSu32)mDNSPlatformOneSecond * 5) |
| 3106 | #define kDefaultReconfirmTimeForNoAnswer ((mDNSu32)mDNSPlatformOneSecond * 5) |
| 3107 | |
| 3108 | // Delay before restarting questions on a flapping interface. |
| 3109 | #define kDefaultQueryDelayTimeForFlappingInterface ((mDNSu32)mDNSPlatformOneSecond * 3) |
| 3110 | // After kDefaultQueryDelayTimeForFlappingInterface seconds, allow enough time for up to three queries (0, 1, and 4 seconds) |
| 3111 | // plus three seconds for "response delay" before removing the reconfirmed records from the cache. |
| 3112 | #define kDefaultReconfirmTimeForFlappingInterface (kDefaultQueryDelayTimeForFlappingInterface + ((mDNSu32)mDNSPlatformOneSecond * 7)) |
| 3113 | |
| 3114 | mDNSexport mStatus mDNS_Reconfirm_internal(mDNS *const m, CacheRecord *const rr, mDNSu32 interval) |
| 3115 | { |
| 3116 | if (interval < kMinimumReconfirmTime) |
| 3117 | interval = kMinimumReconfirmTime; |
| 3118 | if (interval > 0x10000000) // Make sure interval doesn't overflow when we multiply by four below |
| 3119 | interval = 0x10000000; |
| 3120 | |
| 3121 | // If the expected expiration time for this record is more than interval+33%, then accelerate its expiration |
| 3122 | if (RRExpireTime(rr) - m->timenow > (mDNSs32)((interval * 4) / 3)) |
| 3123 | { |
| 3124 | // Add a 33% random amount to the interval, to avoid synchronization between multiple hosts |
| 3125 | // For all the reconfirmations in a given batch, we want to use the same random value |
| 3126 | // so that the reconfirmation questions can be grouped into a single query packet |
| 3127 | if (!m->RandomReconfirmDelay) m->RandomReconfirmDelay = 1 + mDNSRandom(FutureTime); |
| 3128 | interval += m->RandomReconfirmDelay % ((interval/3) + 1); |
| 3129 | rr->TimeRcvd = m->timenow - (mDNSs32)interval * 3; |
| 3130 | rr->resrec.rroriginalttl = (interval * 4 + mDNSPlatformOneSecond - 1) / mDNSPlatformOneSecond; |
| 3131 | SetNextCacheCheckTimeForRecord(m, rr); |
| 3132 | } |
| 3133 | debugf("mDNS_Reconfirm_internal:%6ld ticks to go for %s %p" , |
| 3134 | RRExpireTime(rr) - m->timenow, CRDisplayString(m, rr), rr->CRActiveQuestion); |
| 3135 | return(mStatus_NoError); |
| 3136 | } |
| 3137 | |
| 3138 | // BuildQuestion puts a question into a DNS Query packet and if successful, updates the value of queryptr. |
| 3139 | // It also appends to the list of known answer records that need to be included, |
| 3140 | // and updates the forcast for the size of the known answer section. |
| 3141 | mDNSlocal mDNSBool BuildQuestion(mDNS *const m, const NetworkInterfaceInfo *intf, DNSMessage *query, mDNSu8 **queryptr, |
| 3142 | DNSQuestion *q, CacheRecord ***kalistptrptr, mDNSu32 *answerforecast) |
| 3143 | { |
| 3144 | mDNSBool ucast = (q->LargeAnswers || q->RequestUnicast) && m->CanReceiveUnicastOn5353 && intf->SupportsUnicastMDNSResponse; |
| 3145 | mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0); |
| 3146 | const mDNSu8 *const limit = query->data + NormalMaxDNSMessageData; |
| 3147 | mDNSu8 anoninfo_space = q->AnonInfo ? AnonInfoSpace(q->AnonInfo) : 0; |
| 3148 | mDNSu8 *newptr = putQuestion(query, *queryptr, limit - *answerforecast - anoninfo_space, &q->qname, q->qtype, (mDNSu16)(q->qclass | ucbit)); |
| 3149 | if (!newptr) |
| 3150 | { |
| 3151 | debugf("BuildQuestion: No more space in this packet for question %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 3152 | return(mDNSfalse); |
| 3153 | } |
| 3154 | else |
| 3155 | { |
| 3156 | mDNSu32 forecast = *answerforecast + anoninfo_space; |
| 3157 | const CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 3158 | CacheRecord *rr; |
| 3159 | CacheRecord **ka = *kalistptrptr; // Make a working copy of the pointer we're going to update |
| 3160 | |
| 3161 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache, |
| 3162 | if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface |
| 3163 | !(rr->resrec.RecordType & kDNSRecordTypeUniqueMask) && // which is a shared (i.e. not unique) record type |
| 3164 | rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not already in the known answer list |
| 3165 | rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet |
| 3166 | SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question |
| 3167 | rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow > // and its half-way-to-expiry time is at least 1 second away |
| 3168 | mDNSPlatformOneSecond) // (also ensures we never include goodbye records with TTL=1) |
| 3169 | { |
| 3170 | // We don't want to include unique records in the Known Answer section. The Known Answer section |
| 3171 | // is intended to suppress floods of shared-record replies from many other devices on the network. |
| 3172 | // That concept really does not apply to unique records, and indeed if we do send a query for |
| 3173 | // which we have a unique record already in our cache, then including that unique record as a |
| 3174 | // Known Answer, so as to suppress the only answer we were expecting to get, makes little sense. |
| 3175 | |
| 3176 | *ka = rr; // Link this record into our known answer chain |
| 3177 | ka = &rr->NextInKAList; |
| 3178 | // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n) |
| 3179 | forecast += 12 + rr->resrec.rdestimate; |
| 3180 | // If we're trying to put more than one question in this packet, and it doesn't fit |
| 3181 | // then undo that last question and try again next time |
| 3182 | if (query->h.numQuestions > 1 && newptr + forecast >= limit) |
| 3183 | { |
| 3184 | query->h.numQuestions--; |
| 3185 | debugf("BuildQuestion: Retracting question %##s (%s) new forecast total %d, total questions %d" , |
| 3186 | q->qname.c, DNSTypeName(q->qtype), newptr + forecast - query->data, query->h.numQuestions); |
| 3187 | ka = *kalistptrptr; // Go back to where we started and retract these answer records |
| 3188 | while (*ka) { CacheRecord *c = *ka; *ka = mDNSNULL; ka = &c->NextInKAList; } |
| 3189 | return(mDNSfalse); // Return false, so we'll try again in the next packet |
| 3190 | } |
| 3191 | } |
| 3192 | |
| 3193 | // Success! Update our state pointers, increment UnansweredQueries as appropriate, and return |
| 3194 | *queryptr = newptr; // Update the packet pointer |
| 3195 | *answerforecast = forecast; // Update the forecast |
| 3196 | *kalistptrptr = ka; // Update the known answer list pointer |
| 3197 | if (ucast) q->ExpectUnicastResp = NonZeroTime(m->timenow); |
| 3198 | |
| 3199 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // For every resource record in our cache, |
| 3200 | if (rr->resrec.InterfaceID == q->SendQNow && // received on this interface |
| 3201 | rr->NextInKAList == mDNSNULL && ka != &rr->NextInKAList && // which is not in the known answer list |
| 3202 | SameNameRecordAnswersQuestion(&rr->resrec, q)) // which answers our question |
| 3203 | { |
| 3204 | rr->UnansweredQueries++; // indicate that we're expecting a response |
| 3205 | rr->LastUnansweredTime = m->timenow; |
| 3206 | SetNextCacheCheckTimeForRecord(m, rr); |
| 3207 | } |
| 3208 | |
| 3209 | return(mDNStrue); |
| 3210 | } |
| 3211 | } |
| 3212 | |
| 3213 | // When we have a query looking for a specified name, but there appear to be no answers with |
| 3214 | // that name, ReconfirmAntecedents() is called with depth=0 to start the reconfirmation process |
| 3215 | // for any records in our cache that reference the given name (e.g. PTR and SRV records). |
| 3216 | // For any such cache record we find, we also recursively call ReconfirmAntecedents() for *its* name. |
| 3217 | // We increment depth each time we recurse, to guard against possible infinite loops, with a limit of 5. |
| 3218 | // A typical reconfirmation scenario might go like this: |
| 3219 | // Depth 0: Name "myhost.local" has no address records |
| 3220 | // Depth 1: SRV "My Service._example._tcp.local." refers to "myhost.local"; may be stale |
| 3221 | // Depth 2: PTR "_example._tcp.local." refers to "My Service"; may be stale |
| 3222 | // Depth 3: PTR "_services._dns-sd._udp.local." refers to "_example._tcp.local."; may be stale |
| 3223 | // Currently depths 4 and 5 are not expected to occur; if we did get to depth 5 we'd reconfim any records we |
| 3224 | // found referring to the given name, but not recursively descend any further reconfirm *their* antecedents. |
| 3225 | mDNSlocal void ReconfirmAntecedents(mDNS *const m, const domainname *const name, const mDNSu32 namehash, const int depth) |
| 3226 | { |
| 3227 | mDNSu32 slot; |
| 3228 | CacheGroup *cg; |
| 3229 | CacheRecord *cr; |
| 3230 | debugf("ReconfirmAntecedents (depth=%d) for %##s" , depth, name->c); |
| 3231 | FORALL_CACHERECORDS(slot, cg, cr) |
| 3232 | { |
| 3233 | domainname *crtarget = GetRRDomainNameTarget(&cr->resrec); |
| 3234 | if (crtarget && cr->resrec.rdatahash == namehash && SameDomainName(crtarget, name)) |
| 3235 | { |
| 3236 | LogInfo("ReconfirmAntecedents: Reconfirming (depth=%d) %s" , depth, CRDisplayString(m, cr)); |
| 3237 | mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); |
| 3238 | if (depth < 5) |
| 3239 | ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, depth+1); |
| 3240 | } |
| 3241 | } |
| 3242 | } |
| 3243 | |
| 3244 | // If we get no answer for a AAAA query, then before doing an automatic implicit ReconfirmAntecedents |
| 3245 | // we check if we have an address record for the same name. If we do have an IPv4 address for a given |
| 3246 | // name but not an IPv6 address, that's okay (it just means the device doesn't do IPv6) so the failure |
| 3247 | // to get a AAAA response is not grounds to doubt the PTR/SRV chain that lead us to that name. |
| 3248 | mDNSlocal const CacheRecord *CacheHasAddressTypeForName(mDNS *const m, const domainname *const name, const mDNSu32 namehash) |
| 3249 | { |
| 3250 | CacheGroup *const cg = CacheGroupForName(m, namehash, name); |
| 3251 | const CacheRecord *cr = cg ? cg->members : mDNSNULL; |
| 3252 | while (cr && !RRTypeIsAddressType(cr->resrec.rrtype)) cr=cr->next; |
| 3253 | return(cr); |
| 3254 | } |
| 3255 | |
| 3256 | |
| 3257 | mDNSlocal const CacheRecord *FindSPSInCache1(mDNS *const m, const DNSQuestion *const q, const CacheRecord *const c0, const CacheRecord *const c1) |
| 3258 | { |
| 3259 | #ifndef SPC_DISABLED |
| 3260 | CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 3261 | const CacheRecord *cr, *bestcr = mDNSNULL; |
| 3262 | mDNSu32 bestmetric = 1000000; |
| 3263 | for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next) |
| 3264 | if (cr->resrec.rrtype == kDNSType_PTR && cr->resrec.rdlength >= 6) // If record is PTR type, with long enough name, |
| 3265 | if (cr != c0 && cr != c1) // that's not one we've seen before, |
| 3266 | if (SameNameRecordAnswersQuestion(&cr->resrec, q)) // and answers our browse query, |
| 3267 | if (!IdenticalSameNameRecord(&cr->resrec, &m->SPSRecords.RR_PTR.resrec)) // and is not our own advertised service... |
| 3268 | { |
| 3269 | mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c); |
| 3270 | if (bestmetric > metric) { bestmetric = metric; bestcr = cr; } |
| 3271 | } |
| 3272 | return(bestcr); |
| 3273 | #else // SPC_DISABLED |
| 3274 | (void) m; |
| 3275 | (void) q; |
| 3276 | (void) c0; |
| 3277 | (void) c1; |
| 3278 | (void) c1; |
| 3279 | return mDNSNULL; |
| 3280 | #endif // SPC_DISABLED |
| 3281 | } |
| 3282 | |
| 3283 | mDNSlocal void CheckAndSwapSPS(const CacheRecord **sps1, const CacheRecord **sps2) |
| 3284 | { |
| 3285 | const CacheRecord *swap_sps; |
| 3286 | mDNSu32 metric1, metric2; |
| 3287 | |
| 3288 | if (!(*sps1) || !(*sps2)) return; |
| 3289 | metric1 = SPSMetric((*sps1)->resrec.rdata->u.name.c); |
| 3290 | metric2 = SPSMetric((*sps2)->resrec.rdata->u.name.c); |
| 3291 | if (!SPSFeatures((*sps1)->resrec.rdata->u.name.c) && SPSFeatures((*sps2)->resrec.rdata->u.name.c) && (metric2 >= metric1)) |
| 3292 | { |
| 3293 | swap_sps = *sps1; |
| 3294 | *sps1 = *sps2; |
| 3295 | *sps2 = swap_sps; |
| 3296 | } |
| 3297 | } |
| 3298 | |
| 3299 | mDNSlocal void ReorderSPSByFeature(const CacheRecord *sps[3]) |
| 3300 | { |
| 3301 | CheckAndSwapSPS(&sps[0], &sps[1]); |
| 3302 | CheckAndSwapSPS(&sps[0], &sps[2]); |
| 3303 | CheckAndSwapSPS(&sps[1], &sps[2]); |
| 3304 | } |
| 3305 | |
| 3306 | |
| 3307 | // Finds the three best Sleep Proxies we currently have in our cache |
| 3308 | mDNSexport void FindSPSInCache(mDNS *const m, const DNSQuestion *const q, const CacheRecord *sps[3]) |
| 3309 | { |
| 3310 | sps[0] = FindSPSInCache1(m, q, mDNSNULL, mDNSNULL); |
| 3311 | sps[1] = !sps[0] ? mDNSNULL : FindSPSInCache1(m, q, sps[0], mDNSNULL); |
| 3312 | sps[2] = !sps[1] ? mDNSNULL : FindSPSInCache1(m, q, sps[0], sps[1]); |
| 3313 | |
| 3314 | // SPS is already sorted by metric. We want to move the entries to the beginning of the array |
| 3315 | // only if they have equally good metric and support features. |
| 3316 | ReorderSPSByFeature(sps); |
| 3317 | } |
| 3318 | |
| 3319 | // Only DupSuppressInfos newer than the specified 'time' are allowed to remain active |
| 3320 | mDNSlocal void ExpireDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time) |
| 3321 | { |
| 3322 | int i; |
| 3323 | for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL; |
| 3324 | } |
| 3325 | |
| 3326 | mDNSlocal void ExpireDupSuppressInfoOnInterface(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 time, mDNSInterfaceID InterfaceID) |
| 3327 | { |
| 3328 | int i; |
| 3329 | for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Time - time < 0) ds[i].InterfaceID = mDNSNULL; |
| 3330 | } |
| 3331 | |
| 3332 | mDNSlocal mDNSBool SuppressOnThisInterface(const DupSuppressInfo ds[DupSuppressInfoSize], const NetworkInterfaceInfo * const intf) |
| 3333 | { |
| 3334 | int i; |
| 3335 | mDNSBool v4 = !intf->IPv4Available; // If this interface doesn't do v4, we don't need to find a v4 duplicate of this query |
| 3336 | mDNSBool v6 = !intf->IPv6Available; // If this interface doesn't do v6, we don't need to find a v6 duplicate of this query |
| 3337 | for (i=0; i<DupSuppressInfoSize; i++) |
| 3338 | if (ds[i].InterfaceID == intf->InterfaceID) |
| 3339 | { |
| 3340 | if (ds[i].Type == mDNSAddrType_IPv4) v4 = mDNStrue; |
| 3341 | else if (ds[i].Type == mDNSAddrType_IPv6) v6 = mDNStrue; |
| 3342 | if (v4 && v6) return(mDNStrue); |
| 3343 | } |
| 3344 | return(mDNSfalse); |
| 3345 | } |
| 3346 | |
| 3347 | mDNSlocal void RecordDupSuppressInfo(DupSuppressInfo ds[DupSuppressInfoSize], mDNSs32 Time, mDNSInterfaceID InterfaceID, mDNSs32 Type) |
| 3348 | { |
| 3349 | int i, j; |
| 3350 | |
| 3351 | // See if we have this one in our list somewhere already |
| 3352 | for (i=0; i<DupSuppressInfoSize; i++) if (ds[i].InterfaceID == InterfaceID && ds[i].Type == Type) break; |
| 3353 | |
| 3354 | // If not, find a slot we can re-use |
| 3355 | if (i >= DupSuppressInfoSize) |
| 3356 | { |
| 3357 | i = 0; |
| 3358 | for (j=1; j<DupSuppressInfoSize && ds[i].InterfaceID; j++) |
| 3359 | if (!ds[j].InterfaceID || ds[j].Time - ds[i].Time < 0) |
| 3360 | i = j; |
| 3361 | } |
| 3362 | |
| 3363 | // Record the info about this query we saw |
| 3364 | ds[i].Time = Time; |
| 3365 | ds[i].InterfaceID = InterfaceID; |
| 3366 | ds[i].Type = Type; |
| 3367 | } |
| 3368 | |
| 3369 | mDNSlocal void mDNSSendWakeOnResolve(mDNS *const m, DNSQuestion *q) |
| 3370 | { |
| 3371 | int len, i, cnt; |
| 3372 | mDNSInterfaceID InterfaceID = q->InterfaceID; |
| 3373 | domainname *d = &q->qname; |
| 3374 | |
| 3375 | // We can't send magic packets without knowing which interface to send it on. |
| 3376 | if (InterfaceID == mDNSInterface_Any || LocalOnlyOrP2PInterface(InterfaceID)) |
| 3377 | { |
| 3378 | LogMsg("mDNSSendWakeOnResolve: ERROR!! Invalid InterfaceID %p for question %##s" , InterfaceID, q->qname.c); |
| 3379 | return; |
| 3380 | } |
| 3381 | |
| 3382 | // Split MAC@IPAddress and pass them separately |
| 3383 | len = d->c[0]; |
| 3384 | cnt = 0; |
| 3385 | for (i = 1; i < len; i++) |
| 3386 | { |
| 3387 | if (d->c[i] == '@') |
| 3388 | { |
| 3389 | char EthAddr[18]; // ethernet adddress : 12 bytes + 5 ":" + 1 NULL byte |
| 3390 | char IPAddr[47]; // Max IP address len: 46 bytes (IPv6) + 1 NULL byte |
| 3391 | if (cnt != 5) |
| 3392 | { |
| 3393 | LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, cnt %d" , q->qname.c, cnt); |
| 3394 | return; |
| 3395 | } |
| 3396 | if ((i - 1) > (int) (sizeof(EthAddr) - 1)) |
| 3397 | { |
| 3398 | LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed Ethernet address %##s, length %d" , q->qname.c, i - 1); |
| 3399 | return; |
| 3400 | } |
| 3401 | if ((len - i) > (int)(sizeof(IPAddr) - 1)) |
| 3402 | { |
| 3403 | LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed IP address %##s, length %d" , q->qname.c, len - i); |
| 3404 | return; |
| 3405 | } |
| 3406 | mDNSPlatformMemCopy(EthAddr, &d->c[1], i - 1); |
| 3407 | EthAddr[i - 1] = 0; |
| 3408 | mDNSPlatformMemCopy(IPAddr, &d->c[i + 1], len - i); |
| 3409 | IPAddr[len - i] = 0; |
| 3410 | m->mDNSStats.WakeOnResolves++; |
| 3411 | mDNSPlatformSendWakeupPacket(InterfaceID, EthAddr, IPAddr, InitialWakeOnResolveCount - q->WakeOnResolveCount); |
| 3412 | return; |
| 3413 | } |
| 3414 | else if (d->c[i] == ':') |
| 3415 | cnt++; |
| 3416 | } |
| 3417 | LogMsg("mDNSSendWakeOnResolve: ERROR!! Malformed WakeOnResolve name %##s" , q->qname.c); |
| 3418 | } |
| 3419 | |
| 3420 | |
| 3421 | mDNSlocal mDNSBool AccelerateThisQuery(mDNS *const m, DNSQuestion *q) |
| 3422 | { |
| 3423 | // If more than 90% of the way to the query time, we should unconditionally accelerate it |
| 3424 | if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/10)) |
| 3425 | return(mDNStrue); |
| 3426 | |
| 3427 | // If half-way to next scheduled query time, only accelerate if it will add less than 512 bytes to the packet |
| 3428 | if (TimeToSendThisQuestion(q, m->timenow + q->ThisQInterval/2)) |
| 3429 | { |
| 3430 | // We forecast: qname (n) type (2) class (2) |
| 3431 | mDNSu32 forecast = (mDNSu32)DomainNameLength(&q->qname) + 4; |
| 3432 | const CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 3433 | const CacheRecord *rr; |
| 3434 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) // If we have a resource record in our cache, |
| 3435 | if (rr->resrec.rdlength <= SmallRecordLimit && // which is small enough to sensibly fit in the packet |
| 3436 | SameNameRecordAnswersQuestion(&rr->resrec, q) && // which answers our question |
| 3437 | rr->TimeRcvd + TicksTTL(rr)/2 - m->timenow >= 0 && // and it is less than half-way to expiry |
| 3438 | rr->NextRequiredQuery - (m->timenow + q->ThisQInterval) > 0) // and we'll ask at least once again before NextRequiredQuery |
| 3439 | { |
| 3440 | // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n) |
| 3441 | forecast += 12 + rr->resrec.rdestimate; |
| 3442 | if (forecast >= 512) return(mDNSfalse); // If this would add 512 bytes or more to the packet, don't accelerate |
| 3443 | } |
| 3444 | return(mDNStrue); |
| 3445 | } |
| 3446 | |
| 3447 | return(mDNSfalse); |
| 3448 | } |
| 3449 | |
| 3450 | // How Standard Queries are generated: |
| 3451 | // 1. The Question Section contains the question |
| 3452 | // 2. The Additional Section contains answers we already know, to suppress duplicate responses |
| 3453 | |
| 3454 | // How Probe Queries are generated: |
| 3455 | // 1. The Question Section contains queries for the name we intend to use, with QType=ANY because |
| 3456 | // if some other host is already using *any* records with this name, we want to know about it. |
| 3457 | // 2. The Authority Section contains the proposed values we intend to use for one or more |
| 3458 | // of our records with that name (analogous to the Update section of DNS Update packets) |
| 3459 | // because if some other host is probing at the same time, we each want to know what the other is |
| 3460 | // planning, in order to apply the tie-breaking rule to see who gets to use the name and who doesn't. |
| 3461 | |
| 3462 | mDNSlocal void SendQueries(mDNS *const m) |
| 3463 | { |
| 3464 | mDNSu32 slot; |
| 3465 | CacheGroup *cg; |
| 3466 | CacheRecord *cr; |
| 3467 | AuthRecord *ar; |
| 3468 | int pktcount = 0; |
| 3469 | DNSQuestion *q; |
| 3470 | // For explanation of maxExistingQuestionInterval logic, see comments for maxExistingAnnounceInterval |
| 3471 | mDNSs32 maxExistingQuestionInterval = 0; |
| 3472 | const NetworkInterfaceInfo *intf = GetFirstActiveInterface(m->HostInterfaces); |
| 3473 | CacheRecord *KnownAnswerList = mDNSNULL; |
| 3474 | |
| 3475 | // 1. If time for a query, work out what we need to do |
| 3476 | |
| 3477 | // We're expecting to send a query anyway, so see if any expiring cache records are close enough |
| 3478 | // to their NextRequiredQuery to be worth batching them together with this one |
| 3479 | FORALL_CACHERECORDS(slot, cg, cr) |
| 3480 | { |
| 3481 | if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries) |
| 3482 | { |
| 3483 | if (m->timenow + TicksTTL(cr)/50 - cr->NextRequiredQuery >= 0) |
| 3484 | { |
| 3485 | debugf("Sending %d%% cache expiration query for %s" , 80 + 5 * cr->UnansweredQueries, CRDisplayString(m, cr)); |
| 3486 | q = cr->CRActiveQuestion; |
| 3487 | ExpireDupSuppressInfoOnInterface(q->DupSuppress, m->timenow - TicksTTL(cr)/20, cr->resrec.InterfaceID); |
| 3488 | // For uDNS queries (TargetQID non-zero) we adjust LastQTime, |
| 3489 | // and bump UnansweredQueries so that we don't spin trying to send the same cache expiration query repeatedly |
| 3490 | if (q->Target.type) |
| 3491 | { |
| 3492 | q->SendQNow = mDNSInterfaceMark; // If targeted query, mark it |
| 3493 | } |
| 3494 | else if (!mDNSOpaque16IsZero(q->TargetQID)) |
| 3495 | { |
| 3496 | q->LastQTime = m->timenow - q->ThisQInterval; |
| 3497 | cr->UnansweredQueries++; |
| 3498 | m->mDNSStats.CacheRefreshQueries++; |
| 3499 | } |
| 3500 | else if (q->SendQNow == mDNSNULL) |
| 3501 | { |
| 3502 | q->SendQNow = cr->resrec.InterfaceID; |
| 3503 | } |
| 3504 | else if (q->SendQNow != cr->resrec.InterfaceID) |
| 3505 | { |
| 3506 | q->SendQNow = mDNSInterfaceMark; |
| 3507 | } |
| 3508 | |
| 3509 | // Indicate that this question was marked for sending |
| 3510 | // to update an existing cached answer record. |
| 3511 | // The browse throttling logic below uses this to determine |
| 3512 | // if the query should be sent. |
| 3513 | if (mDNSOpaque16IsZero(q->TargetQID)) |
| 3514 | q->CachedAnswerNeedsUpdate = mDNStrue; |
| 3515 | } |
| 3516 | } |
| 3517 | } |
| 3518 | |
| 3519 | // Scan our list of questions to see which: |
| 3520 | // *WideArea* queries need to be sent |
| 3521 | // *unicast* queries need to be sent |
| 3522 | // *multicast* queries we're definitely going to send |
| 3523 | if (m->CurrentQuestion) |
| 3524 | LogMsg("SendQueries ERROR m->CurrentQuestion already set: %##s (%s)" , m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 3525 | m->CurrentQuestion = m->Questions; |
| 3526 | while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) |
| 3527 | { |
| 3528 | q = m->CurrentQuestion; |
| 3529 | if (q->Target.type && (q->SendQNow || TimeToSendThisQuestion(q, m->timenow))) |
| 3530 | { |
| 3531 | mDNSu8 *qptr = m->omsg.data; |
| 3532 | const mDNSu8 *const limit = m->omsg.data + sizeof(m->omsg.data); |
| 3533 | |
| 3534 | // If we fail to get a new on-demand socket (should only happen cases of the most extreme resource exhaustion), we'll try again next time |
| 3535 | if (!q->LocalSocket) q->LocalSocket = mDNSPlatformUDPSocket(zeroIPPort); |
| 3536 | if (q->LocalSocket) |
| 3537 | { |
| 3538 | InitializeDNSMessage(&m->omsg.h, q->TargetQID, QueryFlags); |
| 3539 | qptr = putQuestion(&m->omsg, qptr, limit, &q->qname, q->qtype, q->qclass); |
| 3540 | mDNSSendDNSMessage(m, &m->omsg, qptr, mDNSInterface_Any, q->LocalSocket, &q->Target, q->TargetPort, mDNSNULL, mDNSNULL, q->UseBackgroundTrafficClass); |
| 3541 | q->ThisQInterval *= QuestionIntervalStep; |
| 3542 | } |
| 3543 | if (q->ThisQInterval > MaxQuestionInterval) |
| 3544 | q->ThisQInterval = MaxQuestionInterval; |
| 3545 | q->LastQTime = m->timenow; |
| 3546 | q->LastQTxTime = m->timenow; |
| 3547 | q->RecentAnswerPkts = 0; |
| 3548 | q->SendQNow = mDNSNULL; |
| 3549 | q->ExpectUnicastResp = NonZeroTime(m->timenow); |
| 3550 | } |
| 3551 | else if (mDNSOpaque16IsZero(q->TargetQID) && !q->Target.type && TimeToSendThisQuestion(q, m->timenow)) |
| 3552 | { |
| 3553 | //LogInfo("Time to send %##s (%s) %d", q->qname.c, DNSTypeName(q->qtype), m->timenow - NextQSendTime(q)); |
| 3554 | q->SendQNow = mDNSInterfaceMark; // Mark this question for sending on all interfaces |
| 3555 | if (maxExistingQuestionInterval < q->ThisQInterval) |
| 3556 | maxExistingQuestionInterval = q->ThisQInterval; |
| 3557 | } |
| 3558 | // If m->CurrentQuestion wasn't modified out from under us, advance it now |
| 3559 | // We can't do this at the start of the loop because uDNS_CheckCurrentQuestion() depends on having |
| 3560 | // m->CurrentQuestion point to the right question |
| 3561 | if (q == m->CurrentQuestion) m->CurrentQuestion = m->CurrentQuestion->next; |
| 3562 | } |
| 3563 | while (m->CurrentQuestion) |
| 3564 | { |
| 3565 | LogInfo("SendQueries question loop 1: Skipping NewQuestion %##s (%s)" , m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 3566 | m->CurrentQuestion = m->CurrentQuestion->next; |
| 3567 | } |
| 3568 | m->CurrentQuestion = mDNSNULL; |
| 3569 | |
| 3570 | // Scan our list of questions |
| 3571 | // (a) to see if there are any more that are worth accelerating, and |
| 3572 | // (b) to update the state variables for *all* the questions we're going to send |
| 3573 | // Note: Don't set NextScheduledQuery until here, because uDNS_CheckCurrentQuestion in the loop above can add new questions to the list, |
| 3574 | // which causes NextScheduledQuery to get (incorrectly) set to m->timenow. Setting it here is the right place, because the very |
| 3575 | // next thing we do is scan the list and call SetNextQueryTime() for every question we find, so we know we end up with the right value. |
| 3576 | m->NextScheduledQuery = m->timenow + FutureTime; |
| 3577 | for (q = m->Questions; q && q != m->NewQuestions; q=q->next) |
| 3578 | { |
| 3579 | if (mDNSOpaque16IsZero(q->TargetQID) |
| 3580 | && (q->SendQNow || (!q->Target.type && ActiveQuestion(q) && q->ThisQInterval <= maxExistingQuestionInterval && AccelerateThisQuery(m,q)))) |
| 3581 | { |
| 3582 | // If at least halfway to next query time, advance to next interval |
| 3583 | // If less than halfway to next query time, then |
| 3584 | // treat this as logically a repeat of the last transmission, without advancing the interval |
| 3585 | if (m->timenow - (q->LastQTime + (q->ThisQInterval/2)) >= 0) |
| 3586 | { |
| 3587 | // If we have reached the answer threshold for this question, |
| 3588 | // don't send it again until MaxQuestionInterval unless: |
| 3589 | // one of its cached answers needs to be refreshed, |
| 3590 | // or it's the initial query for a kDNSServiceFlagsThresholdFinder mode browse. |
| 3591 | if (q->BrowseThreshold |
| 3592 | && (q->CurrentAnswers >= q->BrowseThreshold) |
| 3593 | && (q->CachedAnswerNeedsUpdate == mDNSfalse) |
| 3594 | && !((q->flags & kDNSServiceFlagsThresholdFinder) && (q->ThisQInterval == InitialQuestionInterval))) |
| 3595 | { |
| 3596 | q->SendQNow = mDNSNULL; |
| 3597 | q->ThisQInterval = MaxQuestionInterval; |
| 3598 | q->LastQTime = m->timenow; |
| 3599 | q->RequestUnicast = 0; |
| 3600 | LogInfo("SendQueries: (%s) %##s reached threshold of %d answers" , |
| 3601 | DNSTypeName(q->qtype), q->qname.c, q->BrowseThreshold); |
| 3602 | } |
| 3603 | else |
| 3604 | { |
| 3605 | // Mark this question for sending on all interfaces |
| 3606 | q->SendQNow = mDNSInterfaceMark; |
| 3607 | q->ThisQInterval *= QuestionIntervalStep; |
| 3608 | } |
| 3609 | |
| 3610 | debugf("SendQueries: %##s (%s) next interval %d seconds RequestUnicast = %d" , |
| 3611 | q->qname.c, DNSTypeName(q->qtype), q->ThisQInterval / InitialQuestionInterval, q->RequestUnicast); |
| 3612 | |
| 3613 | if (q->ThisQInterval > MaxQuestionInterval) |
| 3614 | { |
| 3615 | q->ThisQInterval = MaxQuestionInterval; |
| 3616 | } |
| 3617 | else if (q->CurrentAnswers == 0 && q->ThisQInterval == InitialQuestionInterval * QuestionIntervalStep3 && !q->RequestUnicast && |
| 3618 | !(RRTypeIsAddressType(q->qtype) && CacheHasAddressTypeForName(m, &q->qname, q->qnamehash))) |
| 3619 | { |
| 3620 | // Generally don't need to log this. |
| 3621 | // It's not especially noteworthy if a query finds no results -- this usually happens for domain |
| 3622 | // enumeration queries in the LL subdomain (e.g. "db._dns-sd._udp.0.0.254.169.in-addr.arpa") |
| 3623 | // and when there simply happen to be no instances of the service the client is looking |
| 3624 | // for (e.g. iTunes is set to look for RAOP devices, and the current network has none). |
| 3625 | debugf("SendQueries: Zero current answers for %##s (%s); will reconfirm antecedents" , |
| 3626 | q->qname.c, DNSTypeName(q->qtype)); |
| 3627 | // Sending third query, and no answers yet; time to begin doubting the source |
| 3628 | ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0); |
| 3629 | } |
| 3630 | } |
| 3631 | |
| 3632 | // Mark for sending. (If no active interfaces, then don't even try.) |
| 3633 | q->SendOnAll = (q->SendQNow == mDNSInterfaceMark); |
| 3634 | if (q->SendOnAll) |
| 3635 | { |
| 3636 | q->SendQNow = !intf ? mDNSNULL : (q->InterfaceID) ? q->InterfaceID : intf->InterfaceID; |
| 3637 | q->LastQTime = m->timenow; |
| 3638 | } |
| 3639 | |
| 3640 | // If we recorded a duplicate suppression for this question less than half an interval ago, |
| 3641 | // then we consider it recent enough that we don't need to do an identical query ourselves. |
| 3642 | ExpireDupSuppressInfo(q->DupSuppress, m->timenow - q->ThisQInterval/2); |
| 3643 | |
| 3644 | q->LastQTxTime = m->timenow; |
| 3645 | q->RecentAnswerPkts = 0; |
| 3646 | if (q->RequestUnicast) q->RequestUnicast--; |
| 3647 | } |
| 3648 | // For all questions (not just the ones we're sending) check what the next scheduled event will be |
| 3649 | // We don't need to consider NewQuestions here because for those we'll set m->NextScheduledQuery in AnswerNewQuestion |
| 3650 | SetNextQueryTime(m,q); |
| 3651 | } |
| 3652 | |
| 3653 | // 2. Scan our authoritative RR list to see what probes we might need to send |
| 3654 | |
| 3655 | m->NextScheduledProbe = m->timenow + FutureTime; |
| 3656 | |
| 3657 | if (m->CurrentRecord) |
| 3658 | LogMsg("SendQueries ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 3659 | m->CurrentRecord = m->ResourceRecords; |
| 3660 | while (m->CurrentRecord) |
| 3661 | { |
| 3662 | ar = m->CurrentRecord; |
| 3663 | m->CurrentRecord = ar->next; |
| 3664 | if (!AuthRecord_uDNS(ar) && ar->resrec.RecordType == kDNSRecordTypeUnique) // For all records that are still probing... |
| 3665 | { |
| 3666 | // 1. If it's not reached its probe time, just make sure we update m->NextScheduledProbe correctly |
| 3667 | if (m->timenow - (ar->LastAPTime + ar->ThisAPInterval) < 0) |
| 3668 | { |
| 3669 | SetNextAnnounceProbeTime(m, ar); |
| 3670 | } |
| 3671 | // 2. else, if it has reached its probe time, mark it for sending and then update m->NextScheduledProbe correctly |
| 3672 | else if (ar->ProbeCount) |
| 3673 | { |
| 3674 | if (ar->AddressProxy.type == mDNSAddrType_IPv4) |
| 3675 | { |
| 3676 | // There's a problem here. If a host is waking up, and we probe to see if it responds, then |
| 3677 | // it will see those ARP probes as signalling intent to use the address, so it picks a different one. |
| 3678 | // A more benign way to find out if a host is responding to ARPs might be send a standard ARP *request* |
| 3679 | // (using our sender IP address) instead of an ARP *probe* (using all-zero sender IP address). |
| 3680 | // A similar concern may apply to the NDP Probe too. -- SC |
| 3681 | LogSPS("SendQueries ARP Probe %d %s %s" , ar->ProbeCount, InterfaceNameForID(m, ar->resrec.InterfaceID), ARDisplayString(m,ar)); |
| 3682 | SendARP(m, 1, ar, &zerov4Addr, &zeroEthAddr, &ar->AddressProxy.ip.v4, &ar->WakeUp.IMAC); |
| 3683 | } |
| 3684 | else if (ar->AddressProxy.type == mDNSAddrType_IPv6) |
| 3685 | { |
| 3686 | LogSPS("SendQueries NDP Probe %d %s %s" , ar->ProbeCount, InterfaceNameForID(m, ar->resrec.InterfaceID), ARDisplayString(m,ar)); |
| 3687 | // IPv6 source = zero |
| 3688 | // No target hardware address |
| 3689 | // IPv6 target address is address we're probing |
| 3690 | // Ethernet destination address is Ethernet interface address of the Sleep Proxy client we're probing |
| 3691 | SendNDP(m, NDP_Sol, 0, ar, &zerov6Addr, mDNSNULL, &ar->AddressProxy.ip.v6, &ar->WakeUp.IMAC); |
| 3692 | } |
| 3693 | // Mark for sending. (If no active interfaces, then don't even try.) |
| 3694 | ar->SendRNow = (!intf || ar->WakeUp.HMAC.l[0]) ? mDNSNULL : ar->resrec.InterfaceID ? ar->resrec.InterfaceID : intf->InterfaceID; |
| 3695 | ar->LastAPTime = m->timenow; |
| 3696 | // When we have a late conflict that resets a record to probing state we use a special marker value greater |
| 3697 | // than DefaultProbeCountForTypeUnique. Here we detect that state and reset ar->ProbeCount back to the right value. |
| 3698 | if (ar->ProbeCount > DefaultProbeCountForTypeUnique) |
| 3699 | ar->ProbeCount = DefaultProbeCountForTypeUnique; |
| 3700 | ar->ProbeCount--; |
| 3701 | SetNextAnnounceProbeTime(m, ar); |
| 3702 | if (ar->ProbeCount == 0) |
| 3703 | { |
| 3704 | // If this is the last probe for this record, then see if we have any matching records |
| 3705 | // on our duplicate list which should similarly have their ProbeCount cleared to zero... |
| 3706 | AuthRecord *r2; |
| 3707 | for (r2 = m->DuplicateRecords; r2; r2=r2->next) |
| 3708 | if (r2->resrec.RecordType == kDNSRecordTypeUnique && RecordIsLocalDuplicate(r2, ar)) |
| 3709 | r2->ProbeCount = 0; |
| 3710 | // ... then acknowledge this record to the client. |
| 3711 | // We do this optimistically, just as we're about to send the third probe. |
| 3712 | // This helps clients that both advertise and browse, and want to filter themselves |
| 3713 | // from the browse results list, because it helps ensure that the registration |
| 3714 | // confirmation will be delivered 1/4 second *before* the browse "add" event. |
| 3715 | // A potential downside is that we could deliver a registration confirmation and then find out |
| 3716 | // moments later that there's a name conflict, but applications have to be prepared to handle |
| 3717 | // late conflicts anyway (e.g. on connection of network cable, etc.), so this is nothing new. |
| 3718 | if (!ar->Acknowledged) AcknowledgeRecord(m, ar); |
| 3719 | } |
| 3720 | } |
| 3721 | // else, if it has now finished probing, move it to state Verified, |
| 3722 | // and update m->NextScheduledResponse so it will be announced |
| 3723 | else |
| 3724 | { |
| 3725 | if (!ar->Acknowledged) AcknowledgeRecord(m, ar); // Defensive, just in case it got missed somehow |
| 3726 | ar->resrec.RecordType = kDNSRecordTypeVerified; |
| 3727 | ar->ThisAPInterval = DefaultAnnounceIntervalForTypeUnique; |
| 3728 | ar->LastAPTime = m->timenow - DefaultAnnounceIntervalForTypeUnique; |
| 3729 | SetNextAnnounceProbeTime(m, ar); |
| 3730 | } |
| 3731 | } |
| 3732 | } |
| 3733 | m->CurrentRecord = m->DuplicateRecords; |
| 3734 | while (m->CurrentRecord) |
| 3735 | { |
| 3736 | ar = m->CurrentRecord; |
| 3737 | m->CurrentRecord = ar->next; |
| 3738 | if (ar->resrec.RecordType == kDNSRecordTypeUnique && ar->ProbeCount == 0 && !ar->Acknowledged) |
| 3739 | AcknowledgeRecord(m, ar); |
| 3740 | } |
| 3741 | |
| 3742 | // 3. Now we know which queries and probes we're sending, |
| 3743 | // go through our interface list sending the appropriate queries on each interface |
| 3744 | while (intf) |
| 3745 | { |
| 3746 | int OwnerRecordSpace = (m->AnnounceOwner && intf->MAC.l[0]) ? DNSOpt_Header_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC) : 0; |
| 3747 | int TraceRecordSpace = (mDNS_McastTracingEnabled && MDNS_TRACER) ? DNSOpt_Header_Space + DNSOpt_TraceData_Space : 0; |
| 3748 | mDNSu8 *queryptr = m->omsg.data; |
| 3749 | mDNSBool useBackgroundTrafficClass = mDNSfalse; // set if we should use background traffic class |
| 3750 | |
| 3751 | InitializeDNSMessage(&m->omsg.h, zeroID, QueryFlags); |
| 3752 | if (KnownAnswerList) verbosedebugf("SendQueries: KnownAnswerList set... Will continue from previous packet" ); |
| 3753 | if (!KnownAnswerList) |
| 3754 | { |
| 3755 | // Start a new known-answer list |
| 3756 | CacheRecord **kalistptr = &KnownAnswerList; |
| 3757 | mDNSu32 answerforecast = OwnerRecordSpace + TraceRecordSpace; // Start by assuming we'll need at least enough space to put the Owner+Tracer Option |
| 3758 | |
| 3759 | // Put query questions in this packet |
| 3760 | for (q = m->Questions; q && q != m->NewQuestions; q=q->next) |
| 3761 | { |
| 3762 | if (mDNSOpaque16IsZero(q->TargetQID) && (q->SendQNow == intf->InterfaceID)) |
| 3763 | { |
| 3764 | mDNSBool Suppress = mDNSfalse; |
| 3765 | debugf("SendQueries: %s question for %##s (%s) at %d forecast total %d" , |
| 3766 | SuppressOnThisInterface(q->DupSuppress, intf) ? "Suppressing" : "Putting " , |
| 3767 | q->qname.c, DNSTypeName(q->qtype), queryptr - m->omsg.data, queryptr + answerforecast - m->omsg.data); |
| 3768 | |
| 3769 | // If interface is P2P type, verify that query should be sent over it. |
| 3770 | if (!mDNSPlatformValidQuestionForInterface(q, intf)) |
| 3771 | { |
| 3772 | q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf); |
| 3773 | } |
| 3774 | // If we're suppressing this question, or we successfully put it, update its SendQNow state |
| 3775 | else if ((Suppress = SuppressOnThisInterface(q->DupSuppress, intf)) || |
| 3776 | BuildQuestion(m, intf, &m->omsg, &queryptr, q, &kalistptr, &answerforecast)) |
| 3777 | { |
| 3778 | // We successfully added the question to the packet. Make sure that |
| 3779 | // we also send the NSEC3 record if required. BuildQuestion accounted for |
| 3780 | // the space. |
| 3781 | // |
| 3782 | // Note: We don't suppress anonymous questions and hence Suppress should always |
| 3783 | // be zero. |
| 3784 | |
| 3785 | if (Suppress) |
| 3786 | m->mDNSStats.DupQuerySuppressions++; |
| 3787 | |
| 3788 | if (!Suppress && q->AnonInfo) |
| 3789 | { |
| 3790 | debugf("SendQueries: marking for question %##s, Suppress %d" , q->qname.c, Suppress); |
| 3791 | q->AnonInfo->SendNow = intf->InterfaceID; |
| 3792 | } |
| 3793 | q->SendQNow = (q->InterfaceID || !q->SendOnAll) ? mDNSNULL : GetNextActiveInterfaceID(intf); |
| 3794 | if (q->WakeOnResolveCount) |
| 3795 | { |
| 3796 | mDNSSendWakeOnResolve(m, q); |
| 3797 | q->WakeOnResolveCount--; |
| 3798 | } |
| 3799 | |
| 3800 | // use background traffic class if any included question requires it |
| 3801 | if (q->UseBackgroundTrafficClass) |
| 3802 | { |
| 3803 | useBackgroundTrafficClass = mDNStrue; |
| 3804 | } |
| 3805 | } |
| 3806 | } |
| 3807 | } |
| 3808 | |
| 3809 | // Put probe questions in this packet |
| 3810 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 3811 | { |
| 3812 | if (ar->SendRNow != intf->InterfaceID) |
| 3813 | continue; |
| 3814 | |
| 3815 | // If interface is a P2P variant, verify that the probe should be sent over it. |
| 3816 | if (!mDNSPlatformValidRecordForInterface(ar, intf->InterfaceID)) |
| 3817 | { |
| 3818 | ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf); |
| 3819 | ar->IncludeInProbe = mDNSfalse; |
| 3820 | } |
| 3821 | else |
| 3822 | { |
| 3823 | mDNSBool ucast = (ar->ProbeCount >= DefaultProbeCountForTypeUnique-1) && m->CanReceiveUnicastOn5353 && intf->SupportsUnicastMDNSResponse; |
| 3824 | mDNSu16 ucbit = (mDNSu16)(ucast ? kDNSQClass_UnicastResponse : 0); |
| 3825 | const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.numQuestions ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData); |
| 3826 | // We forecast: compressed name (2) type (2) class (2) TTL (4) rdlength (2) rdata (n) |
| 3827 | mDNSu32 forecast = answerforecast + 12 + ar->resrec.rdestimate; |
| 3828 | mDNSBool putProbe = mDNStrue; |
| 3829 | mDNSu16 qclass = ar->resrec.rrclass | ucbit; |
| 3830 | |
| 3831 | {// Determine if this probe question is already in packet's dns message |
| 3832 | const mDNSu8 *questionptr = m->omsg.data; |
| 3833 | DNSQuestion question; |
| 3834 | mDNSu16 n; |
| 3835 | for (n = 0; n < m->omsg.h.numQuestions && questionptr; n++) |
| 3836 | { |
| 3837 | questionptr = getQuestion(&m->omsg, questionptr, limit, mDNSInterface_Any, &question); |
| 3838 | if (questionptr && (question.qtype == kDNSQType_ANY) && (question.qclass == qclass) && |
| 3839 | (question.qnamehash == ar->resrec.namehash) && SameDomainName(&question.qname, ar->resrec.name)) |
| 3840 | { |
| 3841 | putProbe = mDNSfalse; // set to false if already in message |
| 3842 | break; |
| 3843 | } |
| 3844 | } |
| 3845 | } |
| 3846 | |
| 3847 | if (putProbe) |
| 3848 | { |
| 3849 | mDNSu8 *newptr = putQuestion(&m->omsg, queryptr, limit - forecast, ar->resrec.name, kDNSQType_ANY, qclass); |
| 3850 | if (newptr) |
| 3851 | { |
| 3852 | queryptr = newptr; |
| 3853 | answerforecast = forecast; |
| 3854 | ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf); |
| 3855 | ar->IncludeInProbe = mDNStrue; |
| 3856 | verbosedebugf("SendQueries: Put Question %##s (%s) probecount %d InterfaceID= %d %d %d" , |
| 3857 | ar->resrec.name->c, DNSTypeName(ar->resrec.rrtype), ar->ProbeCount, ar->resrec.InterfaceID, ar->resrec.rdestimate, answerforecast); |
| 3858 | } |
| 3859 | } |
| 3860 | else |
| 3861 | { |
| 3862 | ar->SendRNow = (ar->resrec.InterfaceID) ? mDNSNULL : GetNextActiveInterfaceID(intf); |
| 3863 | ar->IncludeInProbe = mDNStrue; |
| 3864 | } |
| 3865 | } |
| 3866 | } |
| 3867 | } |
| 3868 | |
| 3869 | // Put our known answer list (either new one from this question or questions, or remainder of old one from last time) |
| 3870 | while (KnownAnswerList) |
| 3871 | { |
| 3872 | CacheRecord *ka = KnownAnswerList; |
| 3873 | mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - ka->TimeRcvd)) / mDNSPlatformOneSecond; |
| 3874 | mDNSu8 *newptr = PutResourceRecordTTLWithLimit(&m->omsg, queryptr, &m->omsg.h.numAnswers, &ka->resrec, ka->resrec.rroriginalttl - SecsSinceRcvd, |
| 3875 | m->omsg.data + NormalMaxDNSMessageData - OwnerRecordSpace - TraceRecordSpace); |
| 3876 | if (newptr) |
| 3877 | { |
| 3878 | verbosedebugf("SendQueries: Put %##s (%s) at %d - %d" , |
| 3879 | ka->resrec.name->c, DNSTypeName(ka->resrec.rrtype), queryptr - m->omsg.data, newptr - m->omsg.data); |
| 3880 | queryptr = newptr; |
| 3881 | KnownAnswerList = ka->NextInKAList; |
| 3882 | ka->NextInKAList = mDNSNULL; |
| 3883 | } |
| 3884 | else |
| 3885 | { |
| 3886 | // If we ran out of space and we have more than one question in the packet, that's an error -- |
| 3887 | // we shouldn't have put more than one question if there was a risk of us running out of space. |
| 3888 | if (m->omsg.h.numQuestions > 1) |
| 3889 | LogMsg("SendQueries: Put %d answers; No more space for known answers" , m->omsg.h.numAnswers); |
| 3890 | m->omsg.h.flags.b[0] |= kDNSFlag0_TC; |
| 3891 | break; |
| 3892 | } |
| 3893 | } |
| 3894 | |
| 3895 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 3896 | { |
| 3897 | if (ar->IncludeInProbe) |
| 3898 | { |
| 3899 | mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, &ar->resrec); |
| 3900 | ar->IncludeInProbe = mDNSfalse; |
| 3901 | if (newptr) queryptr = newptr; |
| 3902 | else LogMsg("SendQueries: How did we fail to have space for the Update record %s" , ARDisplayString(m,ar)); |
| 3903 | } |
| 3904 | } |
| 3905 | |
| 3906 | for (q = m->Questions; q; q = q->next) |
| 3907 | { |
| 3908 | if (q->AnonInfo && q->AnonInfo->SendNow == intf->InterfaceID) |
| 3909 | { |
| 3910 | mDNSu8 *newptr = PutResourceRecord(&m->omsg, queryptr, &m->omsg.h.numAuthorities, q->AnonInfo->nsec3RR); |
| 3911 | if (newptr) |
| 3912 | { |
| 3913 | debugf("SendQueries: Added NSEC3 record %s on InterfaceID %p" , RRDisplayString(m, q->AnonInfo->nsec3RR), intf->InterfaceID); |
| 3914 | queryptr = newptr; |
| 3915 | } |
| 3916 | else |
| 3917 | { |
| 3918 | LogMsg("SendQueries: ERROR!! Cannot add NSEC3 record %s on InterfaceID %p" , RRDisplayString(m, q->AnonInfo->nsec3RR), intf->InterfaceID); |
| 3919 | } |
| 3920 | q->AnonInfo->SendNow = mDNSNULL; |
| 3921 | } |
| 3922 | } |
| 3923 | |
| 3924 | if (queryptr > m->omsg.data) |
| 3925 | { |
| 3926 | // If we have data to send, add OWNER/TRACER/OWNER+TRACER option if necessary, then send packet |
| 3927 | if (OwnerRecordSpace || TraceRecordSpace) |
| 3928 | { |
| 3929 | AuthRecord opt; |
| 3930 | mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 3931 | opt.resrec.rrclass = NormalMaxDNSMessageData; |
| 3932 | opt.resrec.rdlength = sizeof(rdataOPT); |
| 3933 | opt.resrec.rdestimate = sizeof(rdataOPT); |
| 3934 | if (OwnerRecordSpace && TraceRecordSpace) |
| 3935 | { |
| 3936 | opt.resrec.rdlength += sizeof(rdataOPT); // Two options in this OPT record |
| 3937 | opt.resrec.rdestimate += sizeof(rdataOPT); |
| 3938 | SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); |
| 3939 | SetupTracerOpt(m, &opt.resrec.rdata->u.opt[1]); |
| 3940 | } |
| 3941 | else if (OwnerRecordSpace) |
| 3942 | { |
| 3943 | SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); |
| 3944 | } |
| 3945 | else if (TraceRecordSpace) |
| 3946 | { |
| 3947 | SetupTracerOpt(m, &opt.resrec.rdata->u.opt[0]); |
| 3948 | } |
| 3949 | queryptr = PutResourceRecordTTLWithLimit(&m->omsg, queryptr, &m->omsg.h.numAdditionals, |
| 3950 | &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); |
| 3951 | if (!queryptr) |
| 3952 | { |
| 3953 | LogMsg("SendQueries: How did we fail to have space for %s %s OPT record (%d/%d/%d/%d) %s" , OwnerRecordSpace ? "OWNER" : "" , TraceRecordSpace ? "TRACER" : "" , |
| 3954 | m->omsg.h.numQuestions, m->omsg.h.numAnswers, m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); |
| 3955 | } |
| 3956 | if (queryptr > m->omsg.data + NormalMaxDNSMessageData) |
| 3957 | { |
| 3958 | if (m->omsg.h.numQuestions != 1 || m->omsg.h.numAnswers != 0 || m->omsg.h.numAuthorities != 1 || m->omsg.h.numAdditionals != 1) |
| 3959 | LogMsg("SendQueries: Why did we generate oversized packet with %s %s OPT record %p %p %p (%d/%d/%d/%d) %s" , OwnerRecordSpace ? "OWNER" : "" , |
| 3960 | TraceRecordSpace ? "TRACER" : "" , m->omsg.data, m->omsg.data + NormalMaxDNSMessageData, queryptr, m->omsg.h.numQuestions, m->omsg.h.numAnswers, |
| 3961 | m->omsg.h.numAuthorities, m->omsg.h.numAdditionals, ARDisplayString(m, &opt)); |
| 3962 | } |
| 3963 | } |
| 3964 | |
| 3965 | if ((m->omsg.h.flags.b[0] & kDNSFlag0_TC) && m->omsg.h.numQuestions > 1) |
| 3966 | LogMsg("SendQueries: Should not have more than one question (%d) in a truncated packet" , m->omsg.h.numQuestions); |
| 3967 | debugf("SendQueries: Sending %d Question%s %d Answer%s %d Update%s on %p" , |
| 3968 | m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s" , |
| 3969 | m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s" , |
| 3970 | m->omsg.h.numAuthorities, m->omsg.h.numAuthorities == 1 ? "" : "s" , intf->InterfaceID); |
| 3971 | if (intf->IPv4Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v4, MulticastDNSPort, mDNSNULL, mDNSNULL, useBackgroundTrafficClass); |
| 3972 | if (intf->IPv6Available) mDNSSendDNSMessage(m, &m->omsg, queryptr, intf->InterfaceID, mDNSNULL, &AllDNSLinkGroup_v6, MulticastDNSPort, mDNSNULL, mDNSNULL, useBackgroundTrafficClass); |
| 3973 | if (!m->SuppressSending) m->SuppressSending = NonZeroTime(m->timenow + (mDNSPlatformOneSecond+9)/10); |
| 3974 | if (++pktcount >= 1000) |
| 3975 | { LogMsg("SendQueries exceeded loop limit %d: giving up" , pktcount); break; } |
| 3976 | // There might be more records left in the known answer list, or more questions to send |
| 3977 | // on this interface, so go around one more time and try again. |
| 3978 | } |
| 3979 | else // Nothing more to send on this interface; go to next |
| 3980 | { |
| 3981 | const NetworkInterfaceInfo *next = GetFirstActiveInterface(intf->next); |
| 3982 | #if MDNS_DEBUGMSGS && 0 |
| 3983 | const char *const msg = next ? "SendQueries: Nothing more on %p; moving to %p" : "SendQueries: Nothing more on %p" ; |
| 3984 | debugf(msg, intf, next); |
| 3985 | #endif |
| 3986 | intf = next; |
| 3987 | } |
| 3988 | } |
| 3989 | |
| 3990 | // 4. Final housekeeping |
| 3991 | |
| 3992 | // 4a. Debugging check: Make sure we announced all our records |
| 3993 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 3994 | if (ar->SendRNow) |
| 3995 | { |
| 3996 | if (ar->ARType != AuthRecordLocalOnly && ar->ARType != AuthRecordP2P) |
| 3997 | LogInfo("SendQueries: No active interface %d to send probe: %d %s" , |
| 3998 | IID(ar->SendRNow), IID(ar->resrec.InterfaceID), ARDisplayString(m, ar)); |
| 3999 | ar->SendRNow = mDNSNULL; |
| 4000 | } |
| 4001 | |
| 4002 | // 4b. When we have lingering cache records that we're keeping around for a few seconds in the hope |
| 4003 | // that their interface which went away might come back again, the logic will want to send queries |
| 4004 | // for those records, but we can't because their interface isn't here any more, so to keep the |
| 4005 | // state machine ticking over we just pretend we did so. |
| 4006 | // If the interface does not come back in time, the cache record will expire naturally |
| 4007 | FORALL_CACHERECORDS(slot, cg, cr) |
| 4008 | { |
| 4009 | if (cr->CRActiveQuestion && cr->UnansweredQueries < MaxUnansweredQueries) |
| 4010 | { |
| 4011 | if (m->timenow + TicksTTL(cr)/50 - cr->NextRequiredQuery >= 0) |
| 4012 | { |
| 4013 | cr->UnansweredQueries++; |
| 4014 | cr->CRActiveQuestion->SendQNow = mDNSNULL; |
| 4015 | SetNextCacheCheckTimeForRecord(m, cr); |
| 4016 | } |
| 4017 | } |
| 4018 | } |
| 4019 | |
| 4020 | // 4c. Debugging check: Make sure we sent all our planned questions |
| 4021 | // Do this AFTER the lingering cache records check above, because that will prevent spurious warnings for questions |
| 4022 | // we legitimately couldn't send because the interface is no longer available |
| 4023 | for (q = m->Questions; q; q=q->next) |
| 4024 | { |
| 4025 | if (q->SendQNow) |
| 4026 | { |
| 4027 | DNSQuestion *x; |
| 4028 | for (x = m->NewQuestions; x; x=x->next) if (x == q) break; // Check if this question is a NewQuestion |
| 4029 | // There will not be an active interface for questions applied to mDNSInterface_BLE |
| 4030 | // so don't log the warning in that case. |
| 4031 | if (q->InterfaceID != mDNSInterface_BLE) |
| 4032 | LogInfo("SendQueries: No active interface %d to send %s question: %d %##s (%s)" , |
| 4033 | IID(q->SendQNow), x ? "new" : "old" , IID(q->InterfaceID), q->qname.c, DNSTypeName(q->qtype)); |
| 4034 | q->SendQNow = mDNSNULL; |
| 4035 | } |
| 4036 | q->CachedAnswerNeedsUpdate = mDNSfalse; |
| 4037 | } |
| 4038 | } |
| 4039 | |
| 4040 | mDNSlocal void SendWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *EthAddr, mDNSOpaque48 *password, mDNSBool unicastOnly) |
| 4041 | { |
| 4042 | int i, j; |
| 4043 | |
| 4044 | mDNSu8 *ptr = m->omsg.data; |
| 4045 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); |
| 4046 | if (!intf) { LogMsg("SendARP: No interface with InterfaceID %p found" , InterfaceID); return; } |
| 4047 | |
| 4048 | // 0x00 Destination address |
| 4049 | for (i=0; i<6; i++) *ptr++ = EthAddr->b[i]; |
| 4050 | |
| 4051 | // 0x06 Source address (Note: Since we don't currently set the BIOCSHDRCMPLT option, BPF will fill in the real interface address for us) |
| 4052 | for (i=0; i<6; i++) *ptr++ = intf->MAC.b[0]; |
| 4053 | |
| 4054 | // 0x0C Ethertype (0x0842) |
| 4055 | *ptr++ = 0x08; |
| 4056 | *ptr++ = 0x42; |
| 4057 | |
| 4058 | // 0x0E Wakeup sync sequence |
| 4059 | for (i=0; i<6; i++) *ptr++ = 0xFF; |
| 4060 | |
| 4061 | // 0x14 Wakeup data |
| 4062 | for (j=0; j<16; j++) for (i=0; i<6; i++) *ptr++ = EthAddr->b[i]; |
| 4063 | |
| 4064 | // 0x74 Password |
| 4065 | for (i=0; i<6; i++) *ptr++ = password->b[i]; |
| 4066 | |
| 4067 | mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID); |
| 4068 | |
| 4069 | if (!unicastOnly) |
| 4070 | { |
| 4071 | // For Ethernet switches that don't flood-foward packets with unknown unicast destination MAC addresses, |
| 4072 | // broadcast is the only reliable way to get a wakeup packet to the intended target machine. |
| 4073 | // For 802.11 WPA networks, where a sleeping target machine may have missed a broadcast/multicast |
| 4074 | // key rotation, unicast is the only way to get a wakeup packet to the intended target machine. |
| 4075 | // So, we send one of each, unicast first, then broadcast second. |
| 4076 | for (i=0; i<6; i++) m->omsg.data[i] = 0xFF; |
| 4077 | mDNSPlatformSendRawPacket(m->omsg.data, ptr, InterfaceID); |
| 4078 | } |
| 4079 | } |
| 4080 | |
| 4081 | // *************************************************************************** |
| 4082 | #if COMPILER_LIKES_PRAGMA_MARK |
| 4083 | #pragma mark - |
| 4084 | #pragma mark - RR List Management & Task Management |
| 4085 | #endif |
| 4086 | |
| 4087 | // Whenever a question is answered, reset its state so that we don't query |
| 4088 | // the network repeatedly. This happens first time when we answer the question and |
| 4089 | // and later when we refresh the cache. |
| 4090 | mDNSlocal void ResetQuestionState(mDNS *const m, DNSQuestion *q) |
| 4091 | { |
| 4092 | q->LastQTime = m->timenow; |
| 4093 | q->LastQTxTime = m->timenow; |
| 4094 | q->RecentAnswerPkts = 0; |
| 4095 | q->ThisQInterval = MaxQuestionInterval; |
| 4096 | q->RequestUnicast = 0; |
| 4097 | // Reset unansweredQueries so that we don't penalize this server later when we |
| 4098 | // start sending queries when the cache expires. |
| 4099 | q->unansweredQueries = 0; |
| 4100 | debugf("ResetQuestionState: Set MaxQuestionInterval for %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 4101 | } |
| 4102 | |
| 4103 | // Note: AnswerCurrentQuestionWithResourceRecord can call a user callback, which may change the record list and/or question list. |
| 4104 | // Any code walking either list must use the m->CurrentQuestion (and possibly m->CurrentRecord) mechanism to protect against this. |
| 4105 | // In fact, to enforce this, the routine will *only* answer the question currently pointed to by m->CurrentQuestion, |
| 4106 | // which will be auto-advanced (possibly to NULL) if the client callback cancels the question. |
| 4107 | mDNSexport void AnswerCurrentQuestionWithResourceRecord(mDNS *const m, CacheRecord *const rr, const QC_result AddRecord) |
| 4108 | { |
| 4109 | DNSQuestion *const q = m->CurrentQuestion; |
| 4110 | const mDNSBool followcname = FollowCNAME(q, &rr->resrec, AddRecord); |
| 4111 | |
| 4112 | verbosedebugf("AnswerCurrentQuestionWithResourceRecord:%4lu %s TTL %d %s" , |
| 4113 | q->CurrentAnswers, AddRecord ? "Add" : "Rmv" , rr->resrec.rroriginalttl, CRDisplayString(m, rr)); |
| 4114 | |
| 4115 | // When the response for the question was validated, the entire rrset was validated. If we deliver |
| 4116 | // a RMV for a single record in the rrset, we invalidate the response. If we deliver another add |
| 4117 | // in the future, we will do the revalidation again. |
| 4118 | // |
| 4119 | // Also, if we deliver an ADD for a negative cache record and it has no NSEC/NSEC3, the ValidationStatus needs |
| 4120 | // to be reset. This happens normally when we deliver a "secure" negative response followed by an insecure |
| 4121 | // negative response which can happen e.g., when disconnecting from network that leads to a negative response |
| 4122 | // due to no DNS servers. As we don't deliver RMVs for negative responses that were delivered before, we need |
| 4123 | // to do it on the next ADD of a negative cache record. This ADD could be the result of a timeout, no DNS servers |
| 4124 | // etc. in which case we need to reset the state to make sure we don't deliver them as secure. If this is |
| 4125 | // a real negative response, we would reset the state here and validate the results at the end of this function. |
| 4126 | // or the real response again if we purge the cache. |
| 4127 | if (q->ValidationRequired && ((AddRecord == QC_rmv) || |
| 4128 | (rr->resrec.RecordType == kDNSRecordTypePacketNegative && (AddRecord == QC_add)))) |
| 4129 | { |
| 4130 | q->ValidationStatus = 0; |
| 4131 | q->ValidationState = DNSSECValRequired; |
| 4132 | } |
| 4133 | |
| 4134 | // Normally we don't send out the unicast query if we have answered using our local only auth records e.g., /etc/hosts. |
| 4135 | // But if the query for "A" record has a local answer but query for "AAAA" record has no local answer, we might |
| 4136 | // send the AAAA query out which will come back with CNAME and will also answer the "A" query. To prevent that, |
| 4137 | // we check to see if that query already has a unique local answer. |
| 4138 | if (q->LOAddressAnswers) |
| 4139 | { |
| 4140 | LogInfo("AnswerCurrentQuestionWithResourceRecord: Question %p %##s (%s) not answering with record %s due to " |
| 4141 | "LOAddressAnswers %d" , q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr), |
| 4142 | q->LOAddressAnswers); |
| 4143 | return; |
| 4144 | } |
| 4145 | |
| 4146 | if (QuerySuppressed(q)) |
| 4147 | { |
| 4148 | // If the query is suppressed, then we don't want to answer from the cache. But if this query is |
| 4149 | // supposed to time out, we still want to callback the clients. We do this only for TimeoutQuestions |
| 4150 | // that are timing out, which we know are answered with negative cache record when timing out. |
| 4151 | if (!q->TimeoutQuestion || rr->resrec.RecordType != kDNSRecordTypePacketNegative || (m->timenow - q->StopTime < 0)) |
| 4152 | return; |
| 4153 | } |
| 4154 | |
| 4155 | #if AWD_METRICS |
| 4156 | if ((AddRecord == QC_add) && Question_uDNS(q) && !followcname) |
| 4157 | { |
| 4158 | const domainname * queryName; |
| 4159 | mDNSu32 responseLatencyMs; |
| 4160 | mDNSBool isForCellular; |
| 4161 | |
| 4162 | queryName = q->metrics.originalQName ? q->metrics.originalQName : &q->qname; |
| 4163 | isForCellular = (q->qDNSServer && q->qDNSServer->cellIntf); |
| 4164 | if (!q->metrics.answered) |
| 4165 | { |
| 4166 | if (q->metrics.querySendCount > 0) |
| 4167 | { |
| 4168 | responseLatencyMs = ((m->timenow - q->metrics.firstQueryTime) * 1000) / mDNSPlatformOneSecond; |
| 4169 | } |
| 4170 | else |
| 4171 | { |
| 4172 | responseLatencyMs = 0; |
| 4173 | } |
| 4174 | |
| 4175 | MetricsUpdateDNSQueryStats(queryName, q->qtype, &rr->resrec, q->metrics.querySendCount, responseLatencyMs, isForCellular); |
| 4176 | q->metrics.answered = mDNStrue; |
| 4177 | } |
| 4178 | if (q->metrics.querySendCount > 0) |
| 4179 | { |
| 4180 | MetricsUpdateDNSResolveStats(queryName, &rr->resrec, isForCellular); |
| 4181 | } |
| 4182 | } |
| 4183 | #endif |
| 4184 | // Note: Use caution here. In the case of records with rr->DelayDelivery set, AnswerCurrentQuestionWithResourceRecord(... mDNStrue) |
| 4185 | // may be called twice, once when the record is received, and again when it's time to notify local clients. |
| 4186 | // If any counters or similar are added here, care must be taken to ensure that they are not double-incremented by this. |
| 4187 | |
| 4188 | rr->LastUsed = m->timenow; |
| 4189 | if (AddRecord == QC_add && !q->DuplicateOf && rr->CRActiveQuestion != q) |
| 4190 | { |
| 4191 | if (!rr->CRActiveQuestion) m->rrcache_active++; // If not previously active, increment rrcache_active count |
| 4192 | debugf("AnswerCurrentQuestionWithResourceRecord: Updating CRActiveQuestion from %p to %p for cache record %s, CurrentAnswer %d" , |
| 4193 | rr->CRActiveQuestion, q, CRDisplayString(m,rr), q->CurrentAnswers); |
| 4194 | rr->CRActiveQuestion = q; // We know q is non-null |
| 4195 | SetNextCacheCheckTimeForRecord(m, rr); |
| 4196 | } |
| 4197 | |
| 4198 | // If this is: |
| 4199 | // (a) a no-cache add, where we've already done at least one 'QM' query, or |
| 4200 | // (b) a normal add, where we have at least one unique-type answer, |
| 4201 | // then there's no need to keep polling the network. |
| 4202 | // (If we have an answer in the cache, then we'll automatically ask again in time to stop it expiring.) |
| 4203 | // We do this for mDNS questions and uDNS one-shot questions, but not for |
| 4204 | // uDNS LongLived questions, because that would mess up our LLQ lease renewal timing. |
| 4205 | if ((AddRecord == QC_addnocache && !q->RequestUnicast) || |
| 4206 | (AddRecord == QC_add && (q->ExpectUnique || (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)))) |
| 4207 | if (ActiveQuestion(q) && (mDNSOpaque16IsZero(q->TargetQID) || !q->LongLived)) |
| 4208 | { |
| 4209 | ResetQuestionState(m, q); |
| 4210 | } |
| 4211 | |
| 4212 | if (rr->DelayDelivery) return; // We'll come back later when CacheRecordDeferredAdd() calls us |
| 4213 | |
| 4214 | #if USE_DNS64 |
| 4215 | // If DNS64StateMachine() returns true, then the question was restarted as a different question, so return. |
| 4216 | if (!mDNSOpaque16IsZero(q->TargetQID) && DNS64StateMachine(m, q, &rr->resrec, AddRecord)) return; |
| 4217 | #endif |
| 4218 | |
| 4219 | #ifdef USE_LIBIDN |
| 4220 | if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) // If negative answer, check if we need to try Punycode conversion |
| 4221 | { |
| 4222 | domainname newname; |
| 4223 | if (PerformNextPunycodeConversion(q, &newname)) // Itertative Punycode conversion succeeded, so reissue question with new name |
| 4224 | { |
| 4225 | UDPSocket *const sock = q->LocalSocket; // Save old socket and transaction ID |
| 4226 | const mDNSOpaque16 id = q->TargetQID; |
| 4227 | q->LocalSocket = mDNSNULL; |
| 4228 | mDNS_StopQuery_internal(m, q); // Stop old query |
| 4229 | AssignDomainName(&q->qname, &newname); // Update qname |
| 4230 | q->qnamehash = DomainNameHashValue(&q->qname); // and namehash |
| 4231 | mDNS_StartQuery_internal(m, q); // Start new query |
| 4232 | |
| 4233 | if (sock) // Transplant saved socket, if appropriate |
| 4234 | { |
| 4235 | if (q->DuplicateOf) mDNSPlatformUDPClose(sock); |
| 4236 | else { q->LocalSocket = sock; q->TargetQID = id; } |
| 4237 | } |
| 4238 | return; // All done for now; wait until we get the next answer |
| 4239 | } |
| 4240 | } |
| 4241 | #endif // USE_LIBIDN |
| 4242 | |
| 4243 | // Only deliver negative answers if client has explicitly requested them except when we are forcing a negative response |
| 4244 | // for the purpose of retrying search domains/timeout OR the question is suppressed |
| 4245 | if (rr->resrec.RecordType == kDNSRecordTypePacketNegative || (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype))) |
| 4246 | if (!AddRecord || (AddRecord != QC_suppressed && AddRecord != QC_forceresponse && !q->ReturnIntermed)) return; |
| 4247 | |
| 4248 | // For CNAME results to non-CNAME questions, only inform the client if they explicitly requested that |
| 4249 | if (q->QuestionCallback && !q->NoAnswer && (!followcname || q->ReturnIntermed)) |
| 4250 | { |
| 4251 | mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls |
| 4252 | if (q->qtype != kDNSType_NSEC && RRAssertsNonexistence(&rr->resrec, q->qtype)) |
| 4253 | { |
| 4254 | CacheRecord neg; |
| 4255 | MakeNegativeCacheRecord(m, &neg, &q->qname, q->qnamehash, q->qtype, q->qclass, 1, rr->resrec.InterfaceID, q->qDNSServer); |
| 4256 | q->QuestionCallback(m, q, &neg.resrec, AddRecord); |
| 4257 | } |
| 4258 | else |
| 4259 | { |
| 4260 | #if USE_DNS64 |
| 4261 | if (DNS64ShouldAnswerQuestion(q, &rr->resrec)) |
| 4262 | { |
| 4263 | DNS64AnswerQuestion(m, q, &rr->resrec, AddRecord); |
| 4264 | } |
| 4265 | else |
| 4266 | #endif |
| 4267 | { |
| 4268 | q->QuestionCallback(m, q, &rr->resrec, AddRecord); |
| 4269 | } |
| 4270 | } |
| 4271 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 4272 | } |
| 4273 | // If this is an "Add" operation and this question needs validation, validate the response. |
| 4274 | // In the case of negative responses, extra care should be taken. Negative cache records are |
| 4275 | // used for many purposes. For example, |
| 4276 | // |
| 4277 | // 1) Suppressing questions (SuppressUnusable) |
| 4278 | // 2) Timeout questions |
| 4279 | // 3) The name does not exist |
| 4280 | // 4) No DNS servers are available and we need a quick response for the application |
| 4281 | // |
| 4282 | // (1) and (2) are handled by "QC_add" check as AddRecord would be "QC_forceresponse" or "QC_suppressed" |
| 4283 | // in that case. For (3), it is possible that we don't get nsecs back but we still need to call |
| 4284 | // VerifySignature so that we can deliver the appropriate DNSSEC result. There is no point in verifying |
| 4285 | // signature for (4) and hence the explicit check for q->qDNSServer. |
| 4286 | // |
| 4287 | if (m->CurrentQuestion == q && (AddRecord == QC_add) && !q->ValidatingResponse && q->ValidationRequired && |
| 4288 | q->ValidationState == DNSSECValRequired && q->qDNSServer) |
| 4289 | { |
| 4290 | q->ValidationState = DNSSECValInProgress; |
| 4291 | // Treat it as callback call as that's what dnssec code expects |
| 4292 | mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls |
| 4293 | VerifySignature(m, mDNSNULL, q); |
| 4294 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 4295 | return; |
| 4296 | } |
| 4297 | |
| 4298 | // Note: Proceed with caution here because client callback function is allowed to do anything, |
| 4299 | // including starting/stopping queries, registering/deregistering records, etc. |
| 4300 | // |
| 4301 | // If we get a CNAME back while we are validating the response (i.e., CNAME for DS, DNSKEY, RRSIG), |
| 4302 | // don't follow them. If it is a ValidationRequired question, wait for the CNAME to be validated |
| 4303 | // first before following it |
| 4304 | if ((m->CurrentQuestion == q) && followcname && !ValidatingQuestion(q)) |
| 4305 | AnswerQuestionByFollowingCNAME(m, q, &rr->resrec); |
| 4306 | } |
| 4307 | |
| 4308 | mDNSlocal void CacheRecordDeferredAdd(mDNS *const m, CacheRecord *rr) |
| 4309 | { |
| 4310 | rr->DelayDelivery = 0; |
| 4311 | if (m->CurrentQuestion) |
| 4312 | LogMsg("CacheRecordDeferredAdd ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 4313 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 4314 | m->CurrentQuestion = m->Questions; |
| 4315 | while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) |
| 4316 | { |
| 4317 | DNSQuestion *q = m->CurrentQuestion; |
| 4318 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 4319 | AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add); |
| 4320 | if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now |
| 4321 | m->CurrentQuestion = q->next; |
| 4322 | } |
| 4323 | m->CurrentQuestion = mDNSNULL; |
| 4324 | } |
| 4325 | |
| 4326 | mDNSlocal mDNSs32 CheckForSoonToExpireRecords(mDNS *const m, const domainname *const name, const mDNSu32 namehash, mDNSBool *purge) |
| 4327 | { |
| 4328 | const mDNSs32 threshhold = m->timenow + mDNSPlatformOneSecond; // See if there are any records expiring within one second |
| 4329 | const mDNSs32 start = m->timenow - 0x10000000; |
| 4330 | mDNSs32 delay = start; |
| 4331 | CacheGroup *cg = CacheGroupForName(m, namehash, name); |
| 4332 | const CacheRecord *rr; |
| 4333 | |
| 4334 | if (purge) |
| 4335 | *purge = mDNSfalse; |
| 4336 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 4337 | { |
| 4338 | // If there are records that will expire soon, there are cases that need delayed |
| 4339 | // delivery of events: |
| 4340 | // |
| 4341 | // 1) A new cache entry is about to be added as a replacement. The caller needs to |
| 4342 | // deliver a RMV (for the current old entry) followed by ADD (for the new entry). |
| 4343 | // It needs to schedule the timer for the next cache expiry (ScheduleNextCacheCheckTime), |
| 4344 | // so that the cache entry can be purged (purging causes the RMV followed by ADD) |
| 4345 | // |
| 4346 | // 2) A new question is about to be answered and the caller needs to know whether it's |
| 4347 | // scheduling should be delayed so that the question is not answered with this record. |
| 4348 | // Instead of delivering an ADD (old entry) followed by RMV (old entry) and another ADD |
| 4349 | // (new entry), a single ADD can be delivered by delaying the scheduling of the question |
| 4350 | // immediately. |
| 4351 | // |
| 4352 | // When the unicast cache record is created, it's TTL has been extended beyond its value |
| 4353 | // given in the resource record (See RRAdjustTTL). If it is in the "extended" time, the |
| 4354 | // cache is already expired and we set "purge" to indicate that. When "purge" is set, the |
| 4355 | // return value of the function should be ignored by the callers. |
| 4356 | // |
| 4357 | // Note: For case (1), "purge" argument is NULL and hence the following checks are skipped. |
| 4358 | // It is okay to skip in that case because the cache records have been set to expire almost |
| 4359 | // immediately and the extended time does not apply. |
| 4360 | // |
| 4361 | // Also, if there is already an active question we don't try to optimize as purging the cache |
| 4362 | // would end up delivering RMV for the active question and hence we avoid that. |
| 4363 | |
| 4364 | if (purge && !rr->resrec.InterfaceID && !rr->CRActiveQuestion && rr->resrec.rroriginalttl) |
| 4365 | { |
| 4366 | mDNSu32 uTTL = RRUnadjustedTTL(rr->resrec.rroriginalttl); |
| 4367 | if (m->timenow - (rr->TimeRcvd + ((mDNSs32)uTTL * mDNSPlatformOneSecond)) >= 0) |
| 4368 | { |
| 4369 | LogInfo("CheckForSoonToExpireRecords: %s: rroriginalttl %u, unadjustedTTL %u, currentTTL %u" , |
| 4370 | CRDisplayString(m, rr), rr->resrec.rroriginalttl, uTTL, (m->timenow - rr->TimeRcvd)/mDNSPlatformOneSecond); |
| 4371 | *purge = mDNStrue; |
| 4372 | continue; |
| 4373 | } |
| 4374 | } |
| 4375 | if (threshhold - RRExpireTime(rr) >= 0) // If we have records about to expire within a second |
| 4376 | { |
| 4377 | if (delay - RRExpireTime(rr) < 0) // then delay until after they've been deleted |
| 4378 | delay = RRExpireTime(rr); |
| 4379 | } |
| 4380 | } |
| 4381 | if (delay - start > 0) |
| 4382 | return(NonZeroTime(delay)); |
| 4383 | else |
| 4384 | return(0); |
| 4385 | } |
| 4386 | |
| 4387 | // CacheRecordAdd is only called from CreateNewCacheEntry, *never* directly as a result of a client API call. |
| 4388 | // If new questions are created as a result of invoking client callbacks, they will be added to |
| 4389 | // the end of the question list, and m->NewQuestions will be set to indicate the first new question. |
| 4390 | // rr is a new CacheRecord just received into our cache |
| 4391 | // (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique). |
| 4392 | // Note: CacheRecordAdd calls AnswerCurrentQuestionWithResourceRecord which can call a user callback, |
| 4393 | // which may change the record list and/or question list. |
| 4394 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 4395 | mDNSlocal void CacheRecordAdd(mDNS *const m, CacheRecord *rr) |
| 4396 | { |
| 4397 | DNSQuestion *q; |
| 4398 | |
| 4399 | // We stop when we get to NewQuestions -- if we increment their CurrentAnswers/LargeAnswers/UniqueAnswers |
| 4400 | // counters here we'll end up double-incrementing them when we do it again in AnswerNewQuestion(). |
| 4401 | for (q = m->Questions; q && q != m->NewQuestions; q=q->next) |
| 4402 | { |
| 4403 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 4404 | { |
| 4405 | // If this question is one that's actively sending queries, and it's received ten answers within one |
| 4406 | // second of sending the last query packet, then that indicates some radical network topology change, |
| 4407 | // so reset its exponential backoff back to the start. We must be at least at the eight-second interval |
| 4408 | // to do this. If we're at the four-second interval, or less, there's not much benefit accelerating |
| 4409 | // because we will anyway send another query within a few seconds. The first reset query is sent out |
| 4410 | // randomized over the next four seconds to reduce possible synchronization between machines. |
| 4411 | if (q->LastAnswerPktNum != m->PktNum) |
| 4412 | { |
| 4413 | q->LastAnswerPktNum = m->PktNum; |
| 4414 | if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q) && ++q->RecentAnswerPkts >= 10 && |
| 4415 | q->ThisQInterval > InitialQuestionInterval * QuestionIntervalStep3 && m->timenow - q->LastQTxTime < mDNSPlatformOneSecond) |
| 4416 | { |
| 4417 | LogMsg("CacheRecordAdd: %##s (%s) got immediate answer burst (%d); restarting exponential backoff sequence (%d)" , |
| 4418 | q->qname.c, DNSTypeName(q->qtype), q->RecentAnswerPkts, q->ThisQInterval); |
| 4419 | q->LastQTime = m->timenow - InitialQuestionInterval + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*4); |
| 4420 | q->ThisQInterval = InitialQuestionInterval; |
| 4421 | SetNextQueryTime(m,q); |
| 4422 | } |
| 4423 | } |
| 4424 | verbosedebugf("CacheRecordAdd %p %##s (%s) %lu %#a:%d question %p" , rr, rr->resrec.name->c, |
| 4425 | DNSTypeName(rr->resrec.rrtype), rr->resrec.rroriginalttl, rr->resrec.rDNSServer ? |
| 4426 | &rr->resrec.rDNSServer->addr : mDNSNULL, mDNSVal16(rr->resrec.rDNSServer ? |
| 4427 | rr->resrec.rDNSServer->port : zeroIPPort), q); |
| 4428 | q->CurrentAnswers++; |
| 4429 | |
| 4430 | q->unansweredQueries = 0; |
| 4431 | if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++; |
| 4432 | if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++; |
| 4433 | if (q->CurrentAnswers > 4000) |
| 4434 | { |
| 4435 | static int msgcount = 0; |
| 4436 | if (msgcount++ < 10) |
| 4437 | LogMsg("CacheRecordAdd: %##s (%s) has %d answers; shedding records to resist DOS attack" , |
| 4438 | q->qname.c, DNSTypeName(q->qtype), q->CurrentAnswers); |
| 4439 | rr->resrec.rroriginalttl = 0; |
| 4440 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 4441 | } |
| 4442 | } |
| 4443 | } |
| 4444 | |
| 4445 | if (!rr->DelayDelivery) |
| 4446 | { |
| 4447 | if (m->CurrentQuestion) |
| 4448 | LogMsg("CacheRecordAdd ERROR m->CurrentQuestion already set: %##s (%s)" , m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 4449 | m->CurrentQuestion = m->Questions; |
| 4450 | while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) |
| 4451 | { |
| 4452 | q = m->CurrentQuestion; |
| 4453 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 4454 | AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add); |
| 4455 | if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now |
| 4456 | m->CurrentQuestion = q->next; |
| 4457 | } |
| 4458 | m->CurrentQuestion = mDNSNULL; |
| 4459 | } |
| 4460 | |
| 4461 | SetNextCacheCheckTimeForRecord(m, rr); |
| 4462 | } |
| 4463 | |
| 4464 | // NoCacheAnswer is only called from mDNSCoreReceiveResponse, *never* directly as a result of a client API call. |
| 4465 | // If new questions are created as a result of invoking client callbacks, they will be added to |
| 4466 | // the end of the question list, and m->NewQuestions will be set to indicate the first new question. |
| 4467 | // rr is a new CacheRecord just received from the wire (kDNSRecordTypePacketAns/AnsUnique/Add/AddUnique) |
| 4468 | // but we don't have any place to cache it. We'll deliver question 'add' events now, but we won't have any |
| 4469 | // way to deliver 'remove' events in future, nor will we be able to include this in known-answer lists, |
| 4470 | // so we immediately bump ThisQInterval up to MaxQuestionInterval to avoid pounding the network. |
| 4471 | // Note: NoCacheAnswer calls AnswerCurrentQuestionWithResourceRecord which can call a user callback, |
| 4472 | // which may change the record list and/or question list. |
| 4473 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 4474 | mDNSlocal void NoCacheAnswer(mDNS *const m, CacheRecord *rr) |
| 4475 | { |
| 4476 | LogMsg("No cache space: Delivering non-cached result for %##s" , m->rec.r.resrec.name->c); |
| 4477 | if (m->CurrentQuestion) |
| 4478 | LogMsg("NoCacheAnswer ERROR m->CurrentQuestion already set: %##s (%s)" , m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 4479 | m->CurrentQuestion = m->Questions; |
| 4480 | // We do this for *all* questions, not stopping when we get to m->NewQuestions, |
| 4481 | // since we're not caching the record and we'll get no opportunity to do this later |
| 4482 | while (m->CurrentQuestion) |
| 4483 | { |
| 4484 | DNSQuestion *q = m->CurrentQuestion; |
| 4485 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 4486 | AnswerCurrentQuestionWithResourceRecord(m, rr, QC_addnocache); // QC_addnocache means "don't expect remove events for this" |
| 4487 | if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now |
| 4488 | m->CurrentQuestion = q->next; |
| 4489 | } |
| 4490 | m->CurrentQuestion = mDNSNULL; |
| 4491 | } |
| 4492 | |
| 4493 | // CacheRecordRmv is only called from CheckCacheExpiration, which is called from mDNS_Execute. |
| 4494 | // Note that CacheRecordRmv is *only* called for records that are referenced by at least one active question. |
| 4495 | // If new questions are created as a result of invoking client callbacks, they will be added to |
| 4496 | // the end of the question list, and m->NewQuestions will be set to indicate the first new question. |
| 4497 | // rr is an existing cache CacheRecord that just expired and is being deleted |
| 4498 | // (kDNSRecordTypePacketAns/PacketAnsUnique/PacketAdd/PacketAddUnique). |
| 4499 | // Note: CacheRecordRmv calls AnswerCurrentQuestionWithResourceRecord which can call a user callback, |
| 4500 | // which may change the record list and/or question list. |
| 4501 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 4502 | mDNSlocal void CacheRecordRmv(mDNS *const m, CacheRecord *rr) |
| 4503 | { |
| 4504 | if (m->CurrentQuestion) |
| 4505 | LogMsg("CacheRecordRmv ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 4506 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 4507 | m->CurrentQuestion = m->Questions; |
| 4508 | |
| 4509 | // We stop when we get to NewQuestions -- for new questions their CurrentAnswers/LargeAnswers/UniqueAnswers counters |
| 4510 | // will all still be zero because we haven't yet gone through the cache counting how many answers we have for them. |
| 4511 | while (m->CurrentQuestion && m->CurrentQuestion != m->NewQuestions) |
| 4512 | { |
| 4513 | DNSQuestion *q = m->CurrentQuestion; |
| 4514 | // When a question enters suppressed state, we generate RMV events and generate a negative |
| 4515 | // response. A cache may be present that answers this question e.g., cache entry generated |
| 4516 | // before the question became suppressed. We need to skip the suppressed questions here as |
| 4517 | // the RMV event has already been generated. |
| 4518 | if (!QuerySuppressed(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 4519 | { |
| 4520 | verbosedebugf("CacheRecordRmv %p %s" , rr, CRDisplayString(m, rr)); |
| 4521 | q->FlappingInterface1 = mDNSNULL; |
| 4522 | q->FlappingInterface2 = mDNSNULL; |
| 4523 | |
| 4524 | if (q->CurrentAnswers == 0) |
| 4525 | LogMsg("CacheRecordRmv ERROR!!: How can CurrentAnswers already be zero for %p %##s (%s) DNSServer %#a:%d" , |
| 4526 | q, q->qname.c, DNSTypeName(q->qtype), q->qDNSServer ? &q->qDNSServer->addr : mDNSNULL, |
| 4527 | mDNSVal16(q->qDNSServer ? q->qDNSServer->port : zeroIPPort)); |
| 4528 | else |
| 4529 | { |
| 4530 | q->CurrentAnswers--; |
| 4531 | if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--; |
| 4532 | if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--; |
| 4533 | } |
| 4534 | |
| 4535 | // If we have dropped below the answer threshold for this mDNS question, |
| 4536 | // restart the queries at InitialQuestionInterval. |
| 4537 | if (mDNSOpaque16IsZero(q->TargetQID) && (q->BrowseThreshold > 0) && (q->CurrentAnswers < q->BrowseThreshold)) |
| 4538 | { |
| 4539 | q->ThisQInterval = InitialQuestionInterval; |
| 4540 | q->LastQTime = m->timenow - q->ThisQInterval; |
| 4541 | SetNextQueryTime(m,q); |
| 4542 | LogInfo("CacheRecordRmv: (%s) %##s dropped below threshold of %d answers" , |
| 4543 | DNSTypeName(q->qtype), q->qname.c, q->BrowseThreshold); |
| 4544 | } |
| 4545 | if (rr->resrec.rdata->MaxRDLength) // Never generate "remove" events for negative results |
| 4546 | { |
| 4547 | if (q->CurrentAnswers == 0) |
| 4548 | { |
| 4549 | LogInfo("CacheRecordRmv: Last answer for %##s (%s) expired from cache; will reconfirm antecedents" , |
| 4550 | q->qname.c, DNSTypeName(q->qtype)); |
| 4551 | ReconfirmAntecedents(m, &q->qname, q->qnamehash, 0); |
| 4552 | } |
| 4553 | AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv); |
| 4554 | } |
| 4555 | } |
| 4556 | if (m->CurrentQuestion == q) // If m->CurrentQuestion was not auto-advanced, do it ourselves now |
| 4557 | m->CurrentQuestion = q->next; |
| 4558 | } |
| 4559 | m->CurrentQuestion = mDNSNULL; |
| 4560 | } |
| 4561 | |
| 4562 | mDNSlocal void ReleaseCacheEntity(mDNS *const m, CacheEntity *e) |
| 4563 | { |
| 4564 | #if APPLE_OSX_mDNSResponder && MACOSX_MDNS_MALLOC_DEBUGGING >= 1 |
| 4565 | unsigned int i; |
| 4566 | for (i=0; i<sizeof(*e); i++) ((char*)e)[i] = 0xFF; |
| 4567 | #endif |
| 4568 | e->next = m->rrcache_free; |
| 4569 | m->rrcache_free = e; |
| 4570 | m->rrcache_totalused--; |
| 4571 | } |
| 4572 | |
| 4573 | mDNSlocal void ReleaseCacheGroup(mDNS *const m, CacheGroup **cp) |
| 4574 | { |
| 4575 | CacheEntity *e = (CacheEntity *)(*cp); |
| 4576 | //LogMsg("ReleaseCacheGroup: Releasing CacheGroup for %p, %##s", (*cp)->name->c, (*cp)->name->c); |
| 4577 | if ((*cp)->rrcache_tail != &(*cp)->members) |
| 4578 | LogMsg("ERROR: (*cp)->members == mDNSNULL but (*cp)->rrcache_tail != &(*cp)->members)" ); |
| 4579 | //if ((*cp)->name != (domainname*)((*cp)->namestorage)) |
| 4580 | // LogMsg("ReleaseCacheGroup: %##s, %p %p", (*cp)->name->c, (*cp)->name, (domainname*)((*cp)->namestorage)); |
| 4581 | if ((*cp)->name != (domainname*)((*cp)->namestorage)) mDNSPlatformMemFree((*cp)->name); |
| 4582 | (*cp)->name = mDNSNULL; |
| 4583 | *cp = (*cp)->next; // Cut record from list |
| 4584 | ReleaseCacheEntity(m, e); |
| 4585 | } |
| 4586 | |
| 4587 | mDNSlocal void ReleaseAdditionalCacheRecords(mDNS *const m, CacheRecord **rp) |
| 4588 | { |
| 4589 | while (*rp) |
| 4590 | { |
| 4591 | CacheRecord *rr = *rp; |
| 4592 | *rp = (*rp)->next; // Cut record from list |
| 4593 | if (rr->resrec.rdata && rr->resrec.rdata != (RData*)&rr->smallrdatastorage) |
| 4594 | { |
| 4595 | mDNSPlatformMemFree(rr->resrec.rdata); |
| 4596 | rr->resrec.rdata = mDNSNULL; |
| 4597 | } |
| 4598 | // NSEC or SOA records that are not added to the CacheGroup do not share the name |
| 4599 | // of the CacheGroup. |
| 4600 | if (rr->resrec.name) |
| 4601 | { |
| 4602 | debugf("ReleaseAdditionalCacheRecords: freeing cached record %##s (%s)" , rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype)); |
| 4603 | mDNSPlatformMemFree((void *)rr->resrec.name); |
| 4604 | rr->resrec.name = mDNSNULL; |
| 4605 | } |
| 4606 | // Don't count the NSEC3 records used by anonymous browse/reg |
| 4607 | if (!rr->resrec.InterfaceID) |
| 4608 | { |
| 4609 | m->rrcache_totalused_unicast -= rr->resrec.rdlength; |
| 4610 | if (DNSSECRecordType(rr->resrec.rrtype)) |
| 4611 | BumpDNSSECStats(m, kStatsActionDecrement, kStatsTypeMemoryUsage, rr->resrec.rdlength); |
| 4612 | } |
| 4613 | ReleaseCacheEntity(m, (CacheEntity *)rr); |
| 4614 | } |
| 4615 | } |
| 4616 | |
| 4617 | mDNSexport void ReleaseCacheRecord(mDNS *const m, CacheRecord *r) |
| 4618 | { |
| 4619 | CacheGroup *cg; |
| 4620 | |
| 4621 | //LogMsg("ReleaseCacheRecord: Releasing %s", CRDisplayString(m, r)); |
| 4622 | if (r->resrec.rdata && r->resrec.rdata != (RData*)&r->smallrdatastorage) mDNSPlatformMemFree(r->resrec.rdata); |
| 4623 | r->resrec.rdata = mDNSNULL; |
| 4624 | |
| 4625 | cg = CacheGroupForRecord(m, &r->resrec); |
| 4626 | |
| 4627 | if (!cg) |
| 4628 | { |
| 4629 | // It is okay to have this printed for NSEC/NSEC3s |
| 4630 | LogInfo("ReleaseCacheRecord: ERROR!! cg NULL for %##s (%s)" , r->resrec.name->c, DNSTypeName(r->resrec.rrtype)); |
| 4631 | } |
| 4632 | // When NSEC records are not added to the cache, it is usually cached at the "nsec" list |
| 4633 | // of the CacheRecord. But sometimes they may be freed without adding to the "nsec" list |
| 4634 | // (which is handled below) and in that case it should be freed here. |
| 4635 | if (r->resrec.name && cg && r->resrec.name != cg->name) |
| 4636 | { |
| 4637 | debugf("ReleaseCacheRecord: freeing %##s (%s)" , r->resrec.name->c, DNSTypeName(r->resrec.rrtype)); |
| 4638 | mDNSPlatformMemFree((void *)r->resrec.name); |
| 4639 | } |
| 4640 | r->resrec.name = mDNSNULL; |
| 4641 | |
| 4642 | if (r->resrec.AnonInfo) |
| 4643 | { |
| 4644 | debugf("ReleaseCacheRecord: freeing AnonInfo for %##s (%s)" , r->resrec.name->c, DNSTypeName(r->resrec.rrtype)); |
| 4645 | FreeAnonInfo((void *)r->resrec.AnonInfo); |
| 4646 | } |
| 4647 | r->resrec.AnonInfo = mDNSNULL; |
| 4648 | |
| 4649 | if (!r->resrec.InterfaceID) |
| 4650 | { |
| 4651 | m->rrcache_totalused_unicast -= r->resrec.rdlength; |
| 4652 | if (DNSSECRecordType(r->resrec.rrtype)) |
| 4653 | BumpDNSSECStats(m, kStatsActionDecrement, kStatsTypeMemoryUsage, r->resrec.rdlength); |
| 4654 | } |
| 4655 | |
| 4656 | ReleaseAdditionalCacheRecords(m, &r->nsec); |
| 4657 | ReleaseAdditionalCacheRecords(m, &r->soa); |
| 4658 | |
| 4659 | ReleaseCacheEntity(m, (CacheEntity *)r); |
| 4660 | } |
| 4661 | |
| 4662 | // Note: We want to be careful that we deliver all the CacheRecordRmv calls before delivering |
| 4663 | // CacheRecordDeferredAdd calls. The in-order nature of the cache lists ensures that all |
| 4664 | // callbacks for old records are delivered before callbacks for newer records. |
| 4665 | mDNSlocal void CheckCacheExpiration(mDNS *const m, const mDNSu32 slot, CacheGroup *const cg) |
| 4666 | { |
| 4667 | CacheRecord **rp = &cg->members; |
| 4668 | |
| 4669 | if (m->lock_rrcache) { LogMsg("CheckCacheExpiration ERROR! Cache already locked!" ); return; } |
| 4670 | m->lock_rrcache = 1; |
| 4671 | |
| 4672 | while (*rp) |
| 4673 | { |
| 4674 | CacheRecord *const rr = *rp; |
| 4675 | mDNSs32 event = RRExpireTime(rr); |
| 4676 | if (m->timenow - event >= 0) // If expired, delete it |
| 4677 | { |
| 4678 | *rp = rr->next; // Cut it from the list |
| 4679 | |
| 4680 | verbosedebugf("CheckCacheExpiration: Deleting%7d %7d %p %s" , |
| 4681 | m->timenow - rr->TimeRcvd, rr->resrec.rroriginalttl, rr->CRActiveQuestion, CRDisplayString(m, rr)); |
| 4682 | if (rr->CRActiveQuestion) // If this record has one or more active questions, tell them it's going away |
| 4683 | { |
| 4684 | DNSQuestion *q = rr->CRActiveQuestion; |
| 4685 | // When a cache record is about to expire, we expect to do four queries at 80-82%, 85-87%, 90-92% and |
| 4686 | // then 95-97% of the TTL. If the DNS server does not respond, then we will remove the cache entry |
| 4687 | // before we pick a new DNS server. As the question interval is set to MaxQuestionInterval, we may |
| 4688 | // not send out a query anytime soon. Hence, we need to reset the question interval. If this is |
| 4689 | // a normal deferred ADD case, then AnswerCurrentQuestionWithResourceRecord will reset it to |
| 4690 | // MaxQuestionInterval. If we have inactive questions referring to negative cache entries, |
| 4691 | // don't ressurect them as they will deliver duplicate "No such Record" ADD events |
| 4692 | if (!mDNSOpaque16IsZero(q->TargetQID) && !q->LongLived && ActiveQuestion(q)) |
| 4693 | { |
| 4694 | q->ThisQInterval = InitialQuestionInterval; |
| 4695 | q->LastQTime = m->timenow - q->ThisQInterval; |
| 4696 | SetNextQueryTime(m, q); |
| 4697 | } |
| 4698 | CacheRecordRmv(m, rr); |
| 4699 | m->rrcache_active--; |
| 4700 | } |
| 4701 | ReleaseCacheRecord(m, rr); |
| 4702 | } |
| 4703 | else // else, not expired; see if we need to query |
| 4704 | { |
| 4705 | // If waiting to delay delivery, do nothing until then |
| 4706 | if (rr->DelayDelivery && rr->DelayDelivery - m->timenow > 0) |
| 4707 | event = rr->DelayDelivery; |
| 4708 | else |
| 4709 | { |
| 4710 | if (rr->DelayDelivery) CacheRecordDeferredAdd(m, rr); |
| 4711 | if (rr->CRActiveQuestion && rr->UnansweredQueries < MaxUnansweredQueries) |
| 4712 | { |
| 4713 | if (m->timenow - rr->NextRequiredQuery < 0) // If not yet time for next query |
| 4714 | event = NextCacheCheckEvent(rr); // then just record when we want the next query |
| 4715 | else // else trigger our question to go out now |
| 4716 | { |
| 4717 | // Set NextScheduledQuery to timenow so that SendQueries() will run. |
| 4718 | // SendQueries() will see that we have records close to expiration, and send FEQs for them. |
| 4719 | m->NextScheduledQuery = m->timenow; |
| 4720 | // After sending the query we'll increment UnansweredQueries and call SetNextCacheCheckTimeForRecord(), |
| 4721 | // which will correctly update m->NextCacheCheck for us. |
| 4722 | event = m->timenow + FutureTime; |
| 4723 | } |
| 4724 | } |
| 4725 | } |
| 4726 | verbosedebugf("CheckCacheExpiration:%6d %5d %s" , |
| 4727 | (event - m->timenow) / mDNSPlatformOneSecond, CacheCheckGracePeriod(rr), CRDisplayString(m, rr)); |
| 4728 | if (m->rrcache_nextcheck[slot] - event > 0) |
| 4729 | m->rrcache_nextcheck[slot] = event; |
| 4730 | rp = &rr->next; |
| 4731 | } |
| 4732 | } |
| 4733 | if (cg->rrcache_tail != rp) verbosedebugf("CheckCacheExpiration: Updating CacheGroup tail from %p to %p" , cg->rrcache_tail, rp); |
| 4734 | cg->rrcache_tail = rp; |
| 4735 | m->lock_rrcache = 0; |
| 4736 | } |
| 4737 | |
| 4738 | // "LORecord" includes both LocalOnly and P2P record. This function assumes m->CurrentQuestion is pointing to "q". |
| 4739 | // |
| 4740 | // If "CheckOnly" is set to "true", the question won't be answered but just check to see if there is an answer and |
| 4741 | // returns true if there is an answer. |
| 4742 | // |
| 4743 | // If "CheckOnly" is set to "false", the question will be answered if there is a LocalOnly/P2P record and |
| 4744 | // returns true to indicate the same. |
| 4745 | mDNSlocal mDNSBool AnswerQuestionWithLORecord(mDNS *const m, DNSQuestion *q, mDNSBool checkOnly) |
| 4746 | { |
| 4747 | AuthRecord *lr; |
| 4748 | AuthGroup *ag; |
| 4749 | |
| 4750 | if (m->CurrentRecord) |
| 4751 | LogMsg("AnswerQuestionWithLORecord ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 4752 | |
| 4753 | ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); |
| 4754 | if (ag) |
| 4755 | { |
| 4756 | m->CurrentRecord = ag->members; |
| 4757 | while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords) |
| 4758 | { |
| 4759 | AuthRecord *rr = m->CurrentRecord; |
| 4760 | m->CurrentRecord = rr->next; |
| 4761 | // |
| 4762 | // If the question is mDNSInterface_LocalOnly, all records local to the machine should be used |
| 4763 | // to answer the query. This is handled in AnswerNewLocalOnlyQuestion. |
| 4764 | // |
| 4765 | // We handle mDNSInterface_Any and scoped questions here. See LocalOnlyRecordAnswersQuestion for more |
| 4766 | // details on how we handle this case. For P2P we just handle "Interface_Any" questions. For LocalOnly |
| 4767 | // we handle both mDNSInterface_Any and scoped questions. |
| 4768 | |
| 4769 | if (rr->ARType == AuthRecordLocalOnly || (rr->ARType == AuthRecordP2P && (q->InterfaceID == mDNSInterface_Any || q->InterfaceID == mDNSInterface_BLE))) |
| 4770 | if (LocalOnlyRecordAnswersQuestion(rr, q)) |
| 4771 | { |
| 4772 | if (checkOnly) |
| 4773 | { |
| 4774 | LogInfo("AnswerQuestionWithLORecord: question %##s (%s) answered by %s" , q->qname.c, DNSTypeName(q->qtype), |
| 4775 | ARDisplayString(m, rr)); |
| 4776 | m->CurrentRecord = mDNSNULL; |
| 4777 | return mDNStrue; |
| 4778 | } |
| 4779 | AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); |
| 4780 | if (m->CurrentQuestion != q) |
| 4781 | break; // If callback deleted q, then we're finished here |
| 4782 | } |
| 4783 | } |
| 4784 | } |
| 4785 | m->CurrentRecord = mDNSNULL; |
| 4786 | |
| 4787 | if (m->CurrentQuestion != q) |
| 4788 | { |
| 4789 | LogInfo("AnswerQuestionWithLORecord: Question deleted while while answering LocalOnly record answers" ); |
| 4790 | return mDNStrue; |
| 4791 | } |
| 4792 | |
| 4793 | if (q->LOAddressAnswers) |
| 4794 | { |
| 4795 | LogInfo("AnswerQuestionWithLORecord: Question %p %##s (%s) answered using local auth records LOAddressAnswers %d" , |
| 4796 | q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers); |
| 4797 | return mDNStrue; |
| 4798 | } |
| 4799 | |
| 4800 | // Before we go check the cache and ship this query on the wire, we have to be sure that there are |
| 4801 | // no local records that could possibly answer this question. As we did not check the NewLocalRecords, we |
| 4802 | // need to just peek at them to see whether it will answer this question. If it would answer, pretend |
| 4803 | // that we answered. AnswerAllLocalQuestionsWithLocalAuthRecord will answer shortly. This happens normally |
| 4804 | // when we add new /etc/hosts entries and restart the question. It is a new question and also a new record. |
| 4805 | if (ag) |
| 4806 | { |
| 4807 | lr = ag->NewLocalOnlyRecords; |
| 4808 | while (lr) |
| 4809 | { |
| 4810 | if (UniqueLocalOnlyRecord(lr) && LocalOnlyRecordAnswersQuestion(lr, q)) |
| 4811 | { |
| 4812 | LogInfo("AnswerQuestionWithLORecord: Question %p %##s (%s) will be answered using new local auth records " |
| 4813 | " LOAddressAnswers %d" , q, q->qname.c, DNSTypeName(q->qtype), q->LOAddressAnswers); |
| 4814 | return mDNStrue; |
| 4815 | } |
| 4816 | lr = lr->next; |
| 4817 | } |
| 4818 | } |
| 4819 | return mDNSfalse; |
| 4820 | } |
| 4821 | |
| 4822 | // Today, we suppress questions (not send them on the wire) for several reasons e.g., |
| 4823 | // AAAA query is suppressed because no IPv6 capability or PID is not allowed to make |
| 4824 | // DNS requests. We need to temporarily suspend the suppress status so that we can |
| 4825 | // deliver a negative response (AnswerCurrentQuestionWithResourceRecord does not answer |
| 4826 | // suppressed questions) and reset it back. In the future, if there are other |
| 4827 | // reasons for suppressing the query, this function should be updated. |
| 4828 | mDNSlocal void AnswerSuppressedQuestion(mDNS *const m, DNSQuestion *q) |
| 4829 | { |
| 4830 | mDNSBool SuppressQuery; |
| 4831 | mDNSBool DisallowPID; |
| 4832 | |
| 4833 | // If the client did not set the kDNSServiceFlagsReturnIntermediates flag, then don't generate a negative response, just |
| 4834 | // deactivate the DNSQuestion. |
| 4835 | if (!q->ReturnIntermed) |
| 4836 | { |
| 4837 | q->ThisQInterval = 0; |
| 4838 | return; |
| 4839 | } |
| 4840 | |
| 4841 | SuppressQuery = q->SuppressQuery; |
| 4842 | DisallowPID = q->DisallowPID; |
| 4843 | |
| 4844 | // make sure that QuerySuppressed() returns false |
| 4845 | q->SuppressQuery = mDNSfalse; |
| 4846 | q->DisallowPID = mDNSfalse; |
| 4847 | |
| 4848 | GenerateNegativeResponse(m, mDNSInterface_Any, QC_suppressed); |
| 4849 | |
| 4850 | q->SuppressQuery = SuppressQuery; |
| 4851 | q->DisallowPID = DisallowPID; |
| 4852 | } |
| 4853 | |
| 4854 | mDNSlocal void AnswerNewQuestion(mDNS *const m) |
| 4855 | { |
| 4856 | mDNSBool ShouldQueryImmediately = mDNStrue; |
| 4857 | DNSQuestion *const q = m->NewQuestions; // Grab the question we're going to answer |
| 4858 | #if USE_DNS64 |
| 4859 | if (!mDNSOpaque16IsZero(q->TargetQID)) DNS64HandleNewQuestion(m, q); |
| 4860 | #endif |
| 4861 | CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 4862 | mDNSBool AnsweredFromCache = mDNSfalse; |
| 4863 | |
| 4864 | verbosedebugf("AnswerNewQuestion: Answering %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 4865 | |
| 4866 | if (cg) CheckCacheExpiration(m, HashSlotFromNameHash(q->qnamehash), cg); |
| 4867 | if (m->NewQuestions != q) { LogInfo("AnswerNewQuestion: Question deleted while doing CheckCacheExpiration" ); goto exit; } |
| 4868 | m->NewQuestions = q->next; |
| 4869 | // Advance NewQuestions to the next *after* calling CheckCacheExpiration, because if we advance it first |
| 4870 | // then CheckCacheExpiration may give this question add/remove callbacks, and it's not yet ready for that. |
| 4871 | // |
| 4872 | // Also, CheckCacheExpiration() calls CacheRecordDeferredAdd() and CacheRecordRmv(), which invoke |
| 4873 | // client callbacks, which may delete their own or any other question. Our mechanism for detecting |
| 4874 | // whether our current m->NewQuestions question got deleted by one of these callbacks is to store the |
| 4875 | // value of m->NewQuestions in 'q' before calling CheckCacheExpiration(), and then verify afterwards |
| 4876 | // that they're still the same. If m->NewQuestions has changed (because mDNS_StopQuery_internal |
| 4877 | // advanced it), that means the question was deleted, so we no longer need to worry about answering |
| 4878 | // it (and indeed 'q' is now a dangling pointer, so dereferencing it at all would be bad, and the |
| 4879 | // values we computed for slot and cg are now stale and relate to a question that no longer exists). |
| 4880 | // |
| 4881 | // We can't use the usual m->CurrentQuestion mechanism for this because CacheRecordDeferredAdd() and |
| 4882 | // CacheRecordRmv() both use that themselves when walking the list of (non-new) questions generating callbacks. |
| 4883 | // Fortunately mDNS_StopQuery_internal auto-advances both m->CurrentQuestion *AND* m->NewQuestions when |
| 4884 | // deleting a question, so luckily we have an easy alternative way of detecting if our question got deleted. |
| 4885 | |
| 4886 | if (m->lock_rrcache) LogMsg("AnswerNewQuestion ERROR! Cache already locked!" ); |
| 4887 | // This should be safe, because calling the client's question callback may cause the |
| 4888 | // question list to be modified, but should not ever cause the rrcache list to be modified. |
| 4889 | // If the client's question callback deletes the question, then m->CurrentQuestion will |
| 4890 | // be advanced, and we'll exit out of the loop |
| 4891 | m->lock_rrcache = 1; |
| 4892 | if (m->CurrentQuestion) |
| 4893 | LogMsg("AnswerNewQuestion ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 4894 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 4895 | m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted |
| 4896 | |
| 4897 | if (q->NoAnswer == NoAnswer_Fail) |
| 4898 | { |
| 4899 | LogMsg("AnswerNewQuestion: NoAnswer_Fail %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 4900 | MakeNegativeCacheRecord(m, &m->rec.r, &q->qname, q->qnamehash, q->qtype, q->qclass, 60, mDNSInterface_Any, q->qDNSServer); |
| 4901 | q->NoAnswer = NoAnswer_Normal; // Temporarily turn off answer suppression |
| 4902 | AnswerCurrentQuestionWithResourceRecord(m, &m->rec.r, QC_addnocache); |
| 4903 | // Don't touch the question if it has been stopped already |
| 4904 | if (m->CurrentQuestion == q) q->NoAnswer = NoAnswer_Fail; // Restore NoAnswer state |
| 4905 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 4906 | } |
| 4907 | |
| 4908 | if (m->CurrentQuestion != q) |
| 4909 | { |
| 4910 | LogInfo("AnswerNewQuestion: Question deleted while generating NoAnswer_Fail response" ); |
| 4911 | goto exit; |
| 4912 | } |
| 4913 | |
| 4914 | // See if we want to tell it about LocalOnly/P2P records. If we answered them using LocalOnly |
| 4915 | // or P2P record, then we are done. |
| 4916 | if (AnswerQuestionWithLORecord(m, q, mDNSfalse)) |
| 4917 | goto exit; |
| 4918 | |
| 4919 | // If we are not supposed to answer this question, generate a negative response. |
| 4920 | // Temporarily suspend the SuppressQuery so that AnswerCurrentQuestionWithResourceRecord can answer the question |
| 4921 | // |
| 4922 | // If it is a question trying to validate some response, it already checked the cache for a response. If it still |
| 4923 | // reissues a question it means it could not find the RRSIGs. So, we need to bypass the cache check and send |
| 4924 | // the question out. |
| 4925 | if (QuerySuppressed(q)) |
| 4926 | { |
| 4927 | AnswerSuppressedQuestion(m, q); |
| 4928 | } |
| 4929 | else if (!q->ValidatingResponse) |
| 4930 | { |
| 4931 | CacheRecord *rr; |
| 4932 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 4933 | if (SameNameRecordAnswersQuestion(&rr->resrec, q)) |
| 4934 | { |
| 4935 | // SecsSinceRcvd is whole number of elapsed seconds, rounded down |
| 4936 | mDNSu32 SecsSinceRcvd = ((mDNSu32)(m->timenow - rr->TimeRcvd)) / mDNSPlatformOneSecond; |
| 4937 | if (rr->resrec.rroriginalttl <= SecsSinceRcvd) |
| 4938 | { |
| 4939 | LogMsg("AnswerNewQuestion: How is rr->resrec.rroriginalttl %lu <= SecsSinceRcvd %lu for %s %d %d" , |
| 4940 | rr->resrec.rroriginalttl, SecsSinceRcvd, CRDisplayString(m, rr), m->timenow, rr->TimeRcvd); |
| 4941 | continue; // Go to next one in loop |
| 4942 | } |
| 4943 | |
| 4944 | // If this record set is marked unique, then that means we can reasonably assume we have the whole set |
| 4945 | // -- we don't need to rush out on the network and query immediately to see if there are more answers out there |
| 4946 | if ((rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) || (q->ExpectUnique)) |
| 4947 | ShouldQueryImmediately = mDNSfalse; |
| 4948 | q->CurrentAnswers++; |
| 4949 | if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers++; |
| 4950 | if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers++; |
| 4951 | AnsweredFromCache = mDNStrue; |
| 4952 | AnswerCurrentQuestionWithResourceRecord(m, rr, QC_add); |
| 4953 | if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here |
| 4954 | } |
| 4955 | else if (mDNSOpaque16IsZero(q->TargetQID) && RRTypeIsAddressType(rr->resrec.rrtype) && RRTypeIsAddressType(q->qtype)) |
| 4956 | ShouldQueryImmediately = mDNSfalse; |
| 4957 | } |
| 4958 | // We don't use LogInfo for this "Question deleted" message because it happens so routinely that |
| 4959 | // it's not remotely remarkable, and therefore unlikely to be of much help tracking down bugs. |
| 4960 | if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving cache answers" ); goto exit; } |
| 4961 | |
| 4962 | // Neither a local record nor a cache entry could answer this question. If this question need to be retried |
| 4963 | // with search domains, generate a negative response which will now retry after appending search domains. |
| 4964 | // If the query was suppressed above, we already generated a negative response. When it gets unsuppressed, |
| 4965 | // we will retry with search domains. |
| 4966 | if (!QuerySuppressed(q) && !AnsweredFromCache && q->RetryWithSearchDomains) |
| 4967 | { |
| 4968 | LogInfo("AnswerNewQuestion: Generating response for retrying with search domains %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 4969 | GenerateNegativeResponse(m, mDNSInterface_Any, QC_forceresponse); |
| 4970 | } |
| 4971 | |
| 4972 | if (m->CurrentQuestion != q) { debugf("AnswerNewQuestion: Question deleted while giving negative answer" ); goto exit; } |
| 4973 | |
| 4974 | // Note: When a query gets suppressed or retried with search domains, we de-activate the question. |
| 4975 | // Hence we don't execute the following block of code for those cases. |
| 4976 | if (ShouldQueryImmediately && ActiveQuestion(q)) |
| 4977 | { |
| 4978 | debugf("AnswerNewQuestion: ShouldQueryImmediately %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 4979 | q->ThisQInterval = InitialQuestionInterval; |
| 4980 | q->LastQTime = m->timenow - q->ThisQInterval; |
| 4981 | if (mDNSOpaque16IsZero(q->TargetQID)) // For mDNS, spread packets to avoid a burst of simultaneous queries |
| 4982 | { |
| 4983 | // Compute random delay in the range 1-6 seconds, then divide by 50 to get 20-120ms |
| 4984 | if (!m->RandomQueryDelay) |
| 4985 | m->RandomQueryDelay = (mDNSPlatformOneSecond + mDNSRandom(mDNSPlatformOneSecond*5) - 1) / 50 + 1; |
| 4986 | q->LastQTime += m->RandomQueryDelay; |
| 4987 | } |
| 4988 | } |
| 4989 | |
| 4990 | // IN ALL CASES make sure that m->NextScheduledQuery is set appropriately. |
| 4991 | // In cases where m->NewQuestions->DelayAnswering is set, we may have delayed generating our |
| 4992 | // answers for this question until *after* its scheduled transmission time, in which case |
| 4993 | // m->NextScheduledQuery may now be set to 'never', and in that case -- even though we're *not* doing |
| 4994 | // ShouldQueryImmediately -- we still need to make sure we set m->NextScheduledQuery correctly. |
| 4995 | SetNextQueryTime(m,q); |
| 4996 | |
| 4997 | exit: |
| 4998 | m->CurrentQuestion = mDNSNULL; |
| 4999 | m->lock_rrcache = 0; |
| 5000 | } |
| 5001 | |
| 5002 | // When a NewLocalOnlyQuestion is created, AnswerNewLocalOnlyQuestion runs though our ResourceRecords delivering any |
| 5003 | // appropriate answers, stopping if it reaches a NewLocalOnlyRecord -- these will be handled by AnswerAllLocalQuestionsWithLocalAuthRecord |
| 5004 | mDNSlocal void AnswerNewLocalOnlyQuestion(mDNS *const m) |
| 5005 | { |
| 5006 | AuthGroup *ag; |
| 5007 | DNSQuestion *q = m->NewLocalOnlyQuestions; // Grab the question we're going to answer |
| 5008 | mDNSBool retEv = mDNSfalse; |
| 5009 | m->NewLocalOnlyQuestions = q->next; // Advance NewLocalOnlyQuestions to the next (if any) |
| 5010 | |
| 5011 | debugf("AnswerNewLocalOnlyQuestion: Answering %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 5012 | |
| 5013 | if (m->CurrentQuestion) |
| 5014 | LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 5015 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 5016 | m->CurrentQuestion = q; // Indicate which question we're answering, so we'll know if it gets deleted |
| 5017 | |
| 5018 | if (m->CurrentRecord) |
| 5019 | LogMsg("AnswerNewLocalOnlyQuestion ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 5020 | |
| 5021 | // 1. First walk the LocalOnly records answering the LocalOnly question |
| 5022 | // 2. As LocalOnly questions should also be answered by any other Auth records local to the machine, |
| 5023 | // walk the ResourceRecords list delivering the answers |
| 5024 | ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); |
| 5025 | if (ag) |
| 5026 | { |
| 5027 | m->CurrentRecord = ag->members; |
| 5028 | while (m->CurrentRecord && m->CurrentRecord != ag->NewLocalOnlyRecords) |
| 5029 | { |
| 5030 | AuthRecord *rr = m->CurrentRecord; |
| 5031 | m->CurrentRecord = rr->next; |
| 5032 | if (LocalOnlyRecordAnswersQuestion(rr, q)) |
| 5033 | { |
| 5034 | retEv = mDNStrue; |
| 5035 | AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); |
| 5036 | if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here |
| 5037 | } |
| 5038 | } |
| 5039 | } |
| 5040 | |
| 5041 | if (m->CurrentQuestion == q) |
| 5042 | { |
| 5043 | m->CurrentRecord = m->ResourceRecords; |
| 5044 | |
| 5045 | while (m->CurrentRecord && m->CurrentRecord != m->NewLocalRecords) |
| 5046 | { |
| 5047 | AuthRecord *rr = m->CurrentRecord; |
| 5048 | m->CurrentRecord = rr->next; |
| 5049 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 5050 | { |
| 5051 | retEv = mDNStrue; |
| 5052 | AnswerLocalQuestionWithLocalAuthRecord(m, rr, mDNStrue); |
| 5053 | if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here |
| 5054 | } |
| 5055 | } |
| 5056 | } |
| 5057 | |
| 5058 | // The local host is the authoritative source for LocalOnly questions |
| 5059 | // so if no records exist and client requested intermediates, then generate a negative response |
| 5060 | if (!retEv && (m->CurrentQuestion == q) && q->ReturnIntermed) |
| 5061 | GenerateNegativeResponse(m, mDNSInterface_LocalOnly, QC_forceresponse); |
| 5062 | |
| 5063 | m->CurrentQuestion = mDNSNULL; |
| 5064 | m->CurrentRecord = mDNSNULL; |
| 5065 | } |
| 5066 | |
| 5067 | mDNSlocal CacheEntity *GetCacheEntity(mDNS *const m, const CacheGroup *const PreserveCG) |
| 5068 | { |
| 5069 | CacheEntity *e = mDNSNULL; |
| 5070 | |
| 5071 | if (m->lock_rrcache) { LogMsg("GetFreeCacheRR ERROR! Cache already locked!" ); return(mDNSNULL); } |
| 5072 | m->lock_rrcache = 1; |
| 5073 | |
| 5074 | // If we have no free records, ask the client layer to give us some more memory |
| 5075 | if (!m->rrcache_free && m->MainCallback) |
| 5076 | { |
| 5077 | if (m->rrcache_totalused != m->rrcache_size) |
| 5078 | LogMsg("GetFreeCacheRR: count mismatch: m->rrcache_totalused %lu != m->rrcache_size %lu" , |
| 5079 | m->rrcache_totalused, m->rrcache_size); |
| 5080 | |
| 5081 | // We don't want to be vulnerable to a malicious attacker flooding us with an infinite |
| 5082 | // number of bogus records so that we keep growing our cache until the machine runs out of memory. |
| 5083 | // To guard against this, if our cache grows above 512kB (approx 3168 records at 164 bytes each), |
| 5084 | // and we're actively using less than 1/32 of that cache, then we purge all the unused records |
| 5085 | // and recycle them, instead of allocating more memory. |
| 5086 | if (m->rrcache_size > 5000 && m->rrcache_size / 32 > m->rrcache_active) |
| 5087 | LogInfo("Possible denial-of-service attack in progress: m->rrcache_size %lu; m->rrcache_active %lu" , |
| 5088 | m->rrcache_size, m->rrcache_active); |
| 5089 | else |
| 5090 | { |
| 5091 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 5092 | m->MainCallback(m, mStatus_GrowCache); |
| 5093 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 5094 | } |
| 5095 | } |
| 5096 | |
| 5097 | // If we still have no free records, recycle all the records we can. |
| 5098 | // Enumerating the entire cache is moderately expensive, so when we do it, we reclaim all the records we can in one pass. |
| 5099 | if (!m->rrcache_free) |
| 5100 | { |
| 5101 | mDNSu32 oldtotalused = m->rrcache_totalused; |
| 5102 | mDNSu32 slot; |
| 5103 | for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) |
| 5104 | { |
| 5105 | CacheGroup **cp = &m->rrcache_hash[slot]; |
| 5106 | while (*cp) |
| 5107 | { |
| 5108 | CacheRecord **rp = &(*cp)->members; |
| 5109 | while (*rp) |
| 5110 | { |
| 5111 | // Records that answer still-active questions are not candidates for recycling |
| 5112 | // Records that are currently linked into the CacheFlushRecords list may not be recycled, or we'll crash |
| 5113 | if ((*rp)->CRActiveQuestion || (*rp)->NextInCFList) |
| 5114 | rp=&(*rp)->next; |
| 5115 | else |
| 5116 | { |
| 5117 | CacheRecord *rr = *rp; |
| 5118 | *rp = (*rp)->next; // Cut record from list |
| 5119 | ReleaseCacheRecord(m, rr); |
| 5120 | } |
| 5121 | } |
| 5122 | if ((*cp)->rrcache_tail != rp) |
| 5123 | verbosedebugf("GetFreeCacheRR: Updating rrcache_tail[%lu] from %p to %p" , slot, (*cp)->rrcache_tail, rp); |
| 5124 | (*cp)->rrcache_tail = rp; |
| 5125 | if ((*cp)->members || (*cp)==PreserveCG) cp=&(*cp)->next; |
| 5126 | else ReleaseCacheGroup(m, cp); |
| 5127 | } |
| 5128 | } |
| 5129 | LogInfo("GetCacheEntity recycled %d records to reduce cache from %d to %d" , |
| 5130 | oldtotalused - m->rrcache_totalused, oldtotalused, m->rrcache_totalused); |
| 5131 | } |
| 5132 | |
| 5133 | if (m->rrcache_free) // If there are records in the free list, take one |
| 5134 | { |
| 5135 | e = m->rrcache_free; |
| 5136 | m->rrcache_free = e->next; |
| 5137 | if (++m->rrcache_totalused >= m->rrcache_report) |
| 5138 | { |
| 5139 | LogInfo("RR Cache now using %ld objects" , m->rrcache_totalused); |
| 5140 | if (m->rrcache_report < 100) m->rrcache_report += 10; |
| 5141 | else if (m->rrcache_report < 1000) m->rrcache_report += 100; |
| 5142 | else m->rrcache_report += 1000; |
| 5143 | } |
| 5144 | mDNSPlatformMemZero(e, sizeof(*e)); |
| 5145 | } |
| 5146 | |
| 5147 | m->lock_rrcache = 0; |
| 5148 | |
| 5149 | return(e); |
| 5150 | } |
| 5151 | |
| 5152 | mDNSlocal CacheRecord *GetCacheRecord(mDNS *const m, CacheGroup *cg, mDNSu16 RDLength) |
| 5153 | { |
| 5154 | CacheRecord *r = (CacheRecord *)GetCacheEntity(m, cg); |
| 5155 | if (r) |
| 5156 | { |
| 5157 | r->resrec.rdata = (RData*)&r->smallrdatastorage; // By default, assume we're usually going to be using local storage |
| 5158 | if (RDLength > InlineCacheRDSize) // If RDLength is too big, allocate extra storage |
| 5159 | { |
| 5160 | r->resrec.rdata = (RData*)mDNSPlatformMemAllocate(sizeofRDataHeader + RDLength); |
| 5161 | if (r->resrec.rdata) r->resrec.rdata->MaxRDLength = r->resrec.rdlength = RDLength; |
| 5162 | else { ReleaseCacheEntity(m, (CacheEntity*)r); r = mDNSNULL; } |
| 5163 | } |
| 5164 | } |
| 5165 | return(r); |
| 5166 | } |
| 5167 | |
| 5168 | mDNSlocal CacheGroup *GetCacheGroup(mDNS *const m, const mDNSu32 slot, const ResourceRecord *const rr) |
| 5169 | { |
| 5170 | mDNSu16 namelen = DomainNameLength(rr->name); |
| 5171 | CacheGroup *cg = (CacheGroup*)GetCacheEntity(m, mDNSNULL); |
| 5172 | if (!cg) { LogMsg("GetCacheGroup: Failed to allocate memory for %##s" , rr->name->c); return(mDNSNULL); } |
| 5173 | cg->next = m->rrcache_hash[slot]; |
| 5174 | cg->namehash = rr->namehash; |
| 5175 | cg->members = mDNSNULL; |
| 5176 | cg->rrcache_tail = &cg->members; |
| 5177 | if (namelen > sizeof(cg->namestorage)) |
| 5178 | cg->name = mDNSPlatformMemAllocate(namelen); |
| 5179 | else |
| 5180 | cg->name = (domainname*)cg->namestorage; |
| 5181 | if (!cg->name) |
| 5182 | { |
| 5183 | LogMsg("GetCacheGroup: Failed to allocate name storage for %##s" , rr->name->c); |
| 5184 | ReleaseCacheEntity(m, (CacheEntity*)cg); |
| 5185 | return(mDNSNULL); |
| 5186 | } |
| 5187 | AssignDomainName(cg->name, rr->name); |
| 5188 | |
| 5189 | if (CacheGroupForRecord(m, rr)) LogMsg("GetCacheGroup: Already have CacheGroup for %##s" , rr->name->c); |
| 5190 | m->rrcache_hash[slot] = cg; |
| 5191 | if (CacheGroupForRecord(m, rr) != cg) LogMsg("GetCacheGroup: Not finding CacheGroup for %##s" , rr->name->c); |
| 5192 | |
| 5193 | return(cg); |
| 5194 | } |
| 5195 | |
| 5196 | mDNSexport void mDNS_PurgeCacheResourceRecord(mDNS *const m, CacheRecord *rr) |
| 5197 | { |
| 5198 | mDNS_CheckLock(m); |
| 5199 | |
| 5200 | // Make sure we mark this record as thoroughly expired -- we don't ever want to give |
| 5201 | // a positive answer using an expired record (e.g. from an interface that has gone away). |
| 5202 | // We don't want to clear CRActiveQuestion here, because that would leave the record subject to |
| 5203 | // summary deletion without giving the proper callback to any questions that are monitoring it. |
| 5204 | // By setting UnansweredQueries to MaxUnansweredQueries we ensure it won't trigger any further expiration queries. |
| 5205 | rr->TimeRcvd = m->timenow - mDNSPlatformOneSecond * 60; |
| 5206 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 5207 | rr->resrec.rroriginalttl = 0; |
| 5208 | SetNextCacheCheckTimeForRecord(m, rr); |
| 5209 | } |
| 5210 | |
| 5211 | mDNSexport mDNSs32 mDNS_TimeNow(const mDNS *const m) |
| 5212 | { |
| 5213 | mDNSs32 time; |
| 5214 | mDNSPlatformLock(m); |
| 5215 | if (m->mDNS_busy) |
| 5216 | { |
| 5217 | LogMsg("mDNS_TimeNow called while holding mDNS lock. This is incorrect. Code protected by lock should just use m->timenow." ); |
| 5218 | if (!m->timenow) LogMsg("mDNS_TimeNow: m->mDNS_busy is %ld but m->timenow not set" , m->mDNS_busy); |
| 5219 | } |
| 5220 | |
| 5221 | if (m->timenow) time = m->timenow; |
| 5222 | else time = mDNS_TimeNow_NoLock(m); |
| 5223 | mDNSPlatformUnlock(m); |
| 5224 | return(time); |
| 5225 | } |
| 5226 | |
| 5227 | // To avoid pointless CPU thrash, we use SetSPSProxyListChanged(X) to record the last interface that |
| 5228 | // had its Sleep Proxy client list change, and defer to actual BPF reconfiguration to mDNS_Execute(). |
| 5229 | // (GetNextScheduledEvent() returns "now" when m->SPSProxyListChanged is set) |
| 5230 | #define SetSPSProxyListChanged(X) do { \ |
| 5231 | if (m->SPSProxyListChanged && m->SPSProxyListChanged != (X)) mDNSPlatformUpdateProxyList(m->SPSProxyListChanged); \ |
| 5232 | m->SPSProxyListChanged = (X); } while(0) |
| 5233 | |
| 5234 | // Called from mDNS_Execute() to expire stale proxy records |
| 5235 | mDNSlocal void CheckProxyRecords(mDNS *const m, AuthRecord *list) |
| 5236 | { |
| 5237 | m->CurrentRecord = list; |
| 5238 | while (m->CurrentRecord) |
| 5239 | { |
| 5240 | AuthRecord *rr = m->CurrentRecord; |
| 5241 | if (rr->resrec.RecordType != kDNSRecordTypeDeregistering && rr->WakeUp.HMAC.l[0]) |
| 5242 | { |
| 5243 | // If m->SPSSocket is NULL that means we're not acting as a sleep proxy any more, |
| 5244 | // so we need to cease proxying for *all* records we may have, expired or not. |
| 5245 | if (m->SPSSocket && m->timenow - rr->TimeExpire < 0) // If proxy record not expired yet, update m->NextScheduledSPS |
| 5246 | { |
| 5247 | if (m->NextScheduledSPS - rr->TimeExpire > 0) |
| 5248 | m->NextScheduledSPS = rr->TimeExpire; |
| 5249 | } |
| 5250 | else // else proxy record expired, so remove it |
| 5251 | { |
| 5252 | LogSPS("CheckProxyRecords: Removing %d H-MAC %.6a I-MAC %.6a %d %s" , |
| 5253 | m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, ARDisplayString(m, rr)); |
| 5254 | SetSPSProxyListChanged(rr->resrec.InterfaceID); |
| 5255 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); |
| 5256 | // Don't touch rr after this -- memory may have been free'd |
| 5257 | } |
| 5258 | } |
| 5259 | // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because |
| 5260 | // new records could have been added to the end of the list as a result of that call. |
| 5261 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 5262 | m->CurrentRecord = rr->next; |
| 5263 | } |
| 5264 | } |
| 5265 | |
| 5266 | mDNSlocal void CheckRmvEventsForLocalRecords(mDNS *const m) |
| 5267 | { |
| 5268 | while (m->CurrentRecord) |
| 5269 | { |
| 5270 | AuthRecord *rr = m->CurrentRecord; |
| 5271 | if (rr->AnsweredLocalQ && rr->resrec.RecordType == kDNSRecordTypeDeregistering) |
| 5272 | { |
| 5273 | debugf("CheckRmvEventsForLocalRecords: Generating local RMV events for %s" , ARDisplayString(m, rr)); |
| 5274 | rr->resrec.RecordType = kDNSRecordTypeShared; |
| 5275 | AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNSfalse); |
| 5276 | if (m->CurrentRecord == rr) // If rr still exists in list, restore its state now |
| 5277 | { |
| 5278 | rr->resrec.RecordType = kDNSRecordTypeDeregistering; |
| 5279 | rr->AnsweredLocalQ = mDNSfalse; |
| 5280 | // SendResponses normally calls CompleteDeregistration after sending goodbyes. |
| 5281 | // For LocalOnly records, we don't do that and hence we need to do that here. |
| 5282 | if (RRLocalOnly(rr)) CompleteDeregistration(m, rr); |
| 5283 | } |
| 5284 | } |
| 5285 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not auto-advanced, do it ourselves now |
| 5286 | m->CurrentRecord = rr->next; |
| 5287 | } |
| 5288 | } |
| 5289 | |
| 5290 | mDNSlocal void TimeoutQuestions_internal(mDNS *const m, DNSQuestion* questions, mDNSInterfaceID InterfaceID) |
| 5291 | { |
| 5292 | if (m->CurrentQuestion) |
| 5293 | LogMsg("TimeoutQuestions ERROR m->CurrentQuestion already set: %##s (%s)" , m->CurrentQuestion->qname.c, |
| 5294 | DNSTypeName(m->CurrentQuestion->qtype)); |
| 5295 | m->CurrentQuestion = questions; |
| 5296 | while (m->CurrentQuestion) |
| 5297 | { |
| 5298 | DNSQuestion *const q = m->CurrentQuestion; |
| 5299 | if (q->StopTime) |
| 5300 | { |
| 5301 | if (!q->TimeoutQuestion) |
| 5302 | LogMsg("TimeoutQuestions: ERROR!! TimeoutQuestion not set, but StopTime set for %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 5303 | |
| 5304 | if (m->timenow - q->StopTime >= 0) |
| 5305 | { |
| 5306 | LogInfo("TimeoutQuestions: question %p %##s timed out, time %d" , q, q->qname.c, m->timenow - q->StopTime); |
| 5307 | q->LOAddressAnswers = 0; // unset since timing out the question |
| 5308 | GenerateNegativeResponse(m, InterfaceID, QC_forceresponse); |
| 5309 | if (m->CurrentQuestion == q) q->StopTime = 0; |
| 5310 | } |
| 5311 | else |
| 5312 | { |
| 5313 | if (m->NextScheduledStopTime - q->StopTime > 0) |
| 5314 | m->NextScheduledStopTime = q->StopTime; |
| 5315 | } |
| 5316 | } |
| 5317 | // If m->CurrentQuestion wasn't modified out from under us, advance it now |
| 5318 | // We can't do this at the start of the loop because GenerateNegativeResponse |
| 5319 | // depends on having m->CurrentQuestion point to the right question |
| 5320 | if (m->CurrentQuestion == q) |
| 5321 | m->CurrentQuestion = q->next; |
| 5322 | } |
| 5323 | m->CurrentQuestion = mDNSNULL; |
| 5324 | } |
| 5325 | |
| 5326 | mDNSlocal void TimeoutQuestions(mDNS *const m) |
| 5327 | { |
| 5328 | m->NextScheduledStopTime = m->timenow + FutureTime; // push reschedule of TimeoutQuestions to way off into the future |
| 5329 | TimeoutQuestions_internal(m, m->Questions, mDNSInterface_Any); |
| 5330 | TimeoutQuestions_internal(m, m->LocalOnlyQuestions, mDNSInterface_LocalOnly); |
| 5331 | } |
| 5332 | |
| 5333 | mDNSlocal void mDNSCoreFreeProxyRR(mDNS *const m) |
| 5334 | { |
| 5335 | AuthRecord *rrPtr = m->SPSRRSet, *rrNext = mDNSNULL; |
| 5336 | LogSPS("%s : Freeing stored sleep proxy A/AAAA records" , __func__); |
| 5337 | while (rrPtr) |
| 5338 | { |
| 5339 | rrNext = rrPtr->next; |
| 5340 | mDNSPlatformMemFree(rrPtr); |
| 5341 | rrPtr = rrNext; |
| 5342 | } |
| 5343 | m->SPSRRSet = mDNSNULL; |
| 5344 | } |
| 5345 | |
| 5346 | mDNSexport mDNSs32 mDNS_Execute(mDNS *const m) |
| 5347 | { |
| 5348 | mDNS_Lock(m); // Must grab lock before trying to read m->timenow |
| 5349 | |
| 5350 | if (m->timenow - m->NextScheduledEvent >= 0) |
| 5351 | { |
| 5352 | int i; |
| 5353 | AuthRecord *head, *tail; |
| 5354 | mDNSu32 slot; |
| 5355 | AuthGroup *ag; |
| 5356 | |
| 5357 | verbosedebugf("mDNS_Execute" ); |
| 5358 | |
| 5359 | if (m->CurrentQuestion) |
| 5360 | LogMsg("mDNS_Execute: ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 5361 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 5362 | |
| 5363 | if (m->CurrentRecord) |
| 5364 | LogMsg("mDNS_Execute: ERROR m->CurrentRecord already set: %s" , ARDisplayString(m, m->CurrentRecord)); |
| 5365 | |
| 5366 | // 1. If we're past the probe suppression time, we can clear it |
| 5367 | if (m->SuppressProbes && m->timenow - m->SuppressProbes >= 0) m->SuppressProbes = 0; |
| 5368 | |
| 5369 | // 2. If it's been more than ten seconds since the last probe failure, we can clear the counter |
| 5370 | if (m->NumFailedProbes && m->timenow - m->ProbeFailTime >= mDNSPlatformOneSecond * 10) m->NumFailedProbes = 0; |
| 5371 | |
| 5372 | // 3. Purge our cache of stale old records |
| 5373 | if (m->rrcache_size && m->timenow - m->NextCacheCheck >= 0) |
| 5374 | { |
| 5375 | mDNSu32 numchecked = 0; |
| 5376 | m->NextCacheCheck = m->timenow + FutureTime; |
| 5377 | for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) |
| 5378 | { |
| 5379 | if (m->timenow - m->rrcache_nextcheck[slot] >= 0) |
| 5380 | { |
| 5381 | CacheGroup **cp = &m->rrcache_hash[slot]; |
| 5382 | m->rrcache_nextcheck[slot] = m->timenow + FutureTime; |
| 5383 | while (*cp) |
| 5384 | { |
| 5385 | debugf("m->NextCacheCheck %4d Slot %3d %##s" , numchecked, slot, *cp ? (*cp)->name : (domainname*)"\x04NULL" ); |
| 5386 | numchecked++; |
| 5387 | CheckCacheExpiration(m, slot, *cp); |
| 5388 | if ((*cp)->members) cp=&(*cp)->next; |
| 5389 | else ReleaseCacheGroup(m, cp); |
| 5390 | } |
| 5391 | } |
| 5392 | // Even if we didn't need to actually check this slot yet, still need to |
| 5393 | // factor its nextcheck time into our overall NextCacheCheck value |
| 5394 | if (m->NextCacheCheck - m->rrcache_nextcheck[slot] > 0) |
| 5395 | m->NextCacheCheck = m->rrcache_nextcheck[slot]; |
| 5396 | } |
| 5397 | debugf("m->NextCacheCheck %4d checked, next in %d" , numchecked, m->NextCacheCheck - m->timenow); |
| 5398 | } |
| 5399 | |
| 5400 | if (m->timenow - m->NextScheduledSPS >= 0) |
| 5401 | { |
| 5402 | m->NextScheduledSPS = m->timenow + FutureTime; |
| 5403 | CheckProxyRecords(m, m->DuplicateRecords); // Clear m->DuplicateRecords first, then m->ResourceRecords |
| 5404 | CheckProxyRecords(m, m->ResourceRecords); |
| 5405 | } |
| 5406 | |
| 5407 | SetSPSProxyListChanged(mDNSNULL); // Perform any deferred BPF reconfiguration now |
| 5408 | |
| 5409 | // Check to see if we need to send any keepalives. Do this after we called CheckProxyRecords above |
| 5410 | // as records could have expired during that check |
| 5411 | if (m->timenow - m->NextScheduledKA >= 0) |
| 5412 | { |
| 5413 | m->NextScheduledKA = m->timenow + FutureTime; |
| 5414 | mDNS_SendKeepalives(m); |
| 5415 | } |
| 5416 | |
| 5417 | #if BONJOUR_ON_DEMAND |
| 5418 | if (m->NextBonjourDisableTime && (m->timenow - m->NextBonjourDisableTime >= 0)) |
| 5419 | { |
| 5420 | // Schedule immediate network change processing to leave the multicast group |
| 5421 | // since the delay time has expired since the previous active registration or query. |
| 5422 | m->NetworkChanged = m->timenow; |
| 5423 | m->NextBonjourDisableTime = 0; |
| 5424 | m->BonjourEnabled = 0; |
| 5425 | |
| 5426 | LogInfo("mDNS_Execute: Scheduled network changed processing to leave multicast group." ); |
| 5427 | } |
| 5428 | #endif // BONJOUR_ON_DEMAND |
| 5429 | |
| 5430 | // Clear AnnounceOwner if necessary. (Do this *before* SendQueries() and SendResponses().) |
| 5431 | if (m->AnnounceOwner && m->timenow - m->AnnounceOwner >= 0) |
| 5432 | { |
| 5433 | m->AnnounceOwner = 0; |
| 5434 | |
| 5435 | // This is a good time to reset the delay counter used to prevent spurious conflicts |
| 5436 | m->DelayConflictProcessing = 0; |
| 5437 | } |
| 5438 | |
| 5439 | if (m->DelaySleep && m->timenow - m->DelaySleep >= 0) |
| 5440 | { |
| 5441 | m->DelaySleep = 0; |
| 5442 | if (m->SleepState == SleepState_Transferring) |
| 5443 | { |
| 5444 | LogSPS("Re-sleep delay passed; now checking for Sleep Proxy Servers" ); |
| 5445 | BeginSleepProcessing(m); |
| 5446 | } |
| 5447 | } |
| 5448 | |
| 5449 | // 4. See if we can answer any of our new local questions from the cache |
| 5450 | for (i=0; m->NewQuestions && i<1000; i++) |
| 5451 | { |
| 5452 | if (m->NewQuestions->DelayAnswering && m->timenow - m->NewQuestions->DelayAnswering < 0) break; |
| 5453 | AnswerNewQuestion(m); |
| 5454 | } |
| 5455 | if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewQuestion exceeded loop limit" ); |
| 5456 | |
| 5457 | // Make sure we deliver *all* local RMV events, and clear the corresponding rr->AnsweredLocalQ flags, *before* |
| 5458 | // we begin generating *any* new ADD events in the m->NewLocalOnlyQuestions and m->NewLocalRecords loops below. |
| 5459 | for (i=0; i<1000 && m->LocalRemoveEvents; i++) |
| 5460 | { |
| 5461 | m->LocalRemoveEvents = mDNSfalse; |
| 5462 | m->CurrentRecord = m->ResourceRecords; |
| 5463 | CheckRmvEventsForLocalRecords(m); |
| 5464 | // Walk the LocalOnly records and deliver the RMV events |
| 5465 | for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) |
| 5466 | for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next) |
| 5467 | { |
| 5468 | m->CurrentRecord = ag->members; |
| 5469 | if (m->CurrentRecord) CheckRmvEventsForLocalRecords(m); |
| 5470 | } |
| 5471 | } |
| 5472 | |
| 5473 | if (i >= 1000) LogMsg("mDNS_Execute: m->LocalRemoveEvents exceeded loop limit" ); |
| 5474 | |
| 5475 | for (i=0; m->NewLocalOnlyQuestions && i<1000; i++) AnswerNewLocalOnlyQuestion(m); |
| 5476 | if (i >= 1000) LogMsg("mDNS_Execute: AnswerNewLocalOnlyQuestion exceeded loop limit" ); |
| 5477 | |
| 5478 | head = tail = mDNSNULL; |
| 5479 | for (i=0; i<1000 && m->NewLocalRecords && m->NewLocalRecords != head; i++) |
| 5480 | { |
| 5481 | AuthRecord *rr = m->NewLocalRecords; |
| 5482 | m->NewLocalRecords = m->NewLocalRecords->next; |
| 5483 | if (LocalRecordReady(rr)) |
| 5484 | { |
| 5485 | debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s" , ARDisplayString(m, rr)); |
| 5486 | AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue); |
| 5487 | } |
| 5488 | else if (!rr->next) |
| 5489 | { |
| 5490 | // If we have just one record that is not ready, we don't have to unlink and |
| 5491 | // reinsert. As the NewLocalRecords will be NULL for this case, the loop will |
| 5492 | // terminate and set the NewLocalRecords to rr. |
| 5493 | debugf("mDNS_Execute: Just one LocalAuthRecord %s, breaking out of the loop early" , ARDisplayString(m, rr)); |
| 5494 | if (head != mDNSNULL || m->NewLocalRecords != mDNSNULL) |
| 5495 | LogMsg("mDNS_Execute: ERROR!!: head %p, NewLocalRecords %p" , head, m->NewLocalRecords); |
| 5496 | |
| 5497 | head = rr; |
| 5498 | } |
| 5499 | else |
| 5500 | { |
| 5501 | AuthRecord **p = &m->ResourceRecords; // Find this record in our list of active records |
| 5502 | debugf("mDNS_Execute: Skipping LocalAuthRecord %s" , ARDisplayString(m, rr)); |
| 5503 | // if this is the first record we are skipping, move to the end of the list. |
| 5504 | // if we have already skipped records before, append it at the end. |
| 5505 | while (*p && *p != rr) p=&(*p)->next; |
| 5506 | if (*p) *p = rr->next; // Cut this record from the list |
| 5507 | else { LogMsg("mDNS_Execute: ERROR!! Cannot find record %s in ResourceRecords list" , ARDisplayString(m, rr)); break; } |
| 5508 | if (!head) |
| 5509 | { |
| 5510 | while (*p) p=&(*p)->next; |
| 5511 | *p = rr; |
| 5512 | head = tail = rr; |
| 5513 | } |
| 5514 | else |
| 5515 | { |
| 5516 | tail->next = rr; |
| 5517 | tail = rr; |
| 5518 | } |
| 5519 | rr->next = mDNSNULL; |
| 5520 | } |
| 5521 | } |
| 5522 | m->NewLocalRecords = head; |
| 5523 | debugf("mDNS_Execute: Setting NewLocalRecords to %s" , (head ? ARDisplayString(m, head) : "NULL" )); |
| 5524 | |
| 5525 | if (i >= 1000) LogMsg("mDNS_Execute: m->NewLocalRecords exceeded loop limit" ); |
| 5526 | |
| 5527 | // Check to see if we have any new LocalOnly/P2P records to examine for delivering |
| 5528 | // to our local questions |
| 5529 | if (m->NewLocalOnlyRecords) |
| 5530 | { |
| 5531 | m->NewLocalOnlyRecords = mDNSfalse; |
| 5532 | for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) |
| 5533 | for (ag = m->rrauth.rrauth_hash[slot]; ag; ag = ag->next) |
| 5534 | { |
| 5535 | for (i=0; i<100 && ag->NewLocalOnlyRecords; i++) |
| 5536 | { |
| 5537 | AuthRecord *rr = ag->NewLocalOnlyRecords; |
| 5538 | ag->NewLocalOnlyRecords = ag->NewLocalOnlyRecords->next; |
| 5539 | // LocalOnly records should always be ready as they never probe |
| 5540 | if (LocalRecordReady(rr)) |
| 5541 | { |
| 5542 | debugf("mDNS_Execute: Delivering Add event with LocalAuthRecord %s" , ARDisplayString(m, rr)); |
| 5543 | AnswerAllLocalQuestionsWithLocalAuthRecord(m, rr, mDNStrue); |
| 5544 | } |
| 5545 | else LogMsg("mDNS_Execute: LocalOnlyRecord %s not ready" , ARDisplayString(m, rr)); |
| 5546 | } |
| 5547 | // We limit about 100 per AuthGroup that can be serviced at a time |
| 5548 | if (i >= 100) LogMsg("mDNS_Execute: ag->NewLocalOnlyRecords exceeded loop limit" ); |
| 5549 | } |
| 5550 | } |
| 5551 | |
| 5552 | // 5. See what packets we need to send |
| 5553 | if (m->mDNSPlatformStatus != mStatus_NoError || (m->SleepState == SleepState_Sleeping)) |
| 5554 | DiscardDeregistrations(m); |
| 5555 | if (m->mDNSPlatformStatus == mStatus_NoError && (m->SuppressSending == 0 || m->timenow - m->SuppressSending >= 0)) |
| 5556 | { |
| 5557 | // If the platform code is ready, and we're not suppressing packet generation right now |
| 5558 | // then send our responses, probes, and questions. |
| 5559 | // We check the cache first, because there might be records close to expiring that trigger questions to refresh them. |
| 5560 | // We send queries next, because there might be final-stage probes that complete their probing here, causing |
| 5561 | // them to advance to announcing state, and we want those to be included in any announcements we send out. |
| 5562 | // Finally, we send responses, including the previously mentioned records that just completed probing. |
| 5563 | m->SuppressSending = 0; |
| 5564 | |
| 5565 | // 6. Send Query packets. This may cause some probing records to advance to announcing state |
| 5566 | if (m->timenow - m->NextScheduledQuery >= 0 || m->timenow - m->NextScheduledProbe >= 0) SendQueries(m); |
| 5567 | if (m->timenow - m->NextScheduledQuery >= 0) |
| 5568 | { |
| 5569 | DNSQuestion *q; |
| 5570 | LogMsg("mDNS_Execute: SendQueries didn't send all its queries (%d - %d = %d) will try again in one second" , |
| 5571 | m->timenow, m->NextScheduledQuery, m->timenow - m->NextScheduledQuery); |
| 5572 | m->NextScheduledQuery = m->timenow + mDNSPlatformOneSecond; |
| 5573 | for (q = m->Questions; q && q != m->NewQuestions; q=q->next) |
| 5574 | if (ActiveQuestion(q) && m->timenow - NextQSendTime(q) >= 0) |
| 5575 | LogMsg("mDNS_Execute: SendQueries didn't send %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 5576 | } |
| 5577 | if (m->timenow - m->NextScheduledProbe >= 0) |
| 5578 | { |
| 5579 | LogMsg("mDNS_Execute: SendQueries didn't send all its probes (%d - %d = %d) will try again in one second" , |
| 5580 | m->timenow, m->NextScheduledProbe, m->timenow - m->NextScheduledProbe); |
| 5581 | m->NextScheduledProbe = m->timenow + mDNSPlatformOneSecond; |
| 5582 | } |
| 5583 | |
| 5584 | // 7. Send Response packets, including probing records just advanced to announcing state |
| 5585 | if (m->timenow - m->NextScheduledResponse >= 0) SendResponses(m); |
| 5586 | if (m->timenow - m->NextScheduledResponse >= 0) |
| 5587 | { |
| 5588 | LogMsg("mDNS_Execute: SendResponses didn't send all its responses; will try again in one second" ); |
| 5589 | m->NextScheduledResponse = m->timenow + mDNSPlatformOneSecond; |
| 5590 | } |
| 5591 | } |
| 5592 | |
| 5593 | // Clear RandomDelay values, ready to pick a new different value next time |
| 5594 | m->RandomQueryDelay = 0; |
| 5595 | m->RandomReconfirmDelay = 0; |
| 5596 | |
| 5597 | // See if any questions (or local-only questions) have timed out |
| 5598 | if (m->NextScheduledStopTime && m->timenow - m->NextScheduledStopTime >= 0) TimeoutQuestions(m); |
| 5599 | #ifndef UNICAST_DISABLED |
| 5600 | if (m->NextSRVUpdate && m->timenow - m->NextSRVUpdate >= 0) UpdateAllSRVRecords(m); |
| 5601 | if (m->timenow - m->NextScheduledNATOp >= 0) CheckNATMappings(m); |
| 5602 | if (m->timenow - m->NextuDNSEvent >= 0) uDNS_Tasks(m); |
| 5603 | #endif |
| 5604 | #if APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR |
| 5605 | extern void serviceBLE(); |
| 5606 | if (m->NextBLEServiceTime && (m->timenow - m->NextBLEServiceTime >= 0)) serviceBLE(); |
| 5607 | #endif // APPLE_OSX_mDNSResponder && ENABLE_BLE_TRIGGERED_BONJOUR |
| 5608 | } |
| 5609 | |
| 5610 | // Note about multi-threaded systems: |
| 5611 | // On a multi-threaded system, some other thread could run right after the mDNS_Unlock(), |
| 5612 | // performing mDNS API operations that change our next scheduled event time. |
| 5613 | // |
| 5614 | // On multi-threaded systems (like the current Windows implementation) that have a single main thread |
| 5615 | // calling mDNS_Execute() (and other threads allowed to call mDNS API routines) it is the responsibility |
| 5616 | // of the mDNSPlatformUnlock() routine to signal some kind of stateful condition variable that will |
| 5617 | // signal whatever blocking primitive the main thread is using, so that it will wake up and execute one |
| 5618 | // more iteration of its loop, and immediately call mDNS_Execute() again. The signal has to be stateful |
| 5619 | // in the sense that if the main thread has not yet entered its blocking primitive, then as soon as it |
| 5620 | // does, the state of the signal will be noticed, causing the blocking primitive to return immediately |
| 5621 | // without blocking. This avoids the race condition between the signal from the other thread arriving |
| 5622 | // just *before* or just *after* the main thread enters the blocking primitive. |
| 5623 | // |
| 5624 | // On multi-threaded systems (like the current Mac OS 9 implementation) that are entirely timer-driven, |
| 5625 | // with no main mDNS_Execute() thread, it is the responsibility of the mDNSPlatformUnlock() routine to |
| 5626 | // set the timer according to the m->NextScheduledEvent value, and then when the timer fires, the timer |
| 5627 | // callback function should call mDNS_Execute() (and ignore the return value, which may already be stale |
| 5628 | // by the time it gets to the timer callback function). |
| 5629 | |
| 5630 | mDNS_Unlock(m); // Calling mDNS_Unlock is what gives m->NextScheduledEvent its new value |
| 5631 | return(m->NextScheduledEvent); |
| 5632 | } |
| 5633 | |
| 5634 | #ifndef UNICAST_DISABLED |
| 5635 | mDNSlocal void SuspendLLQs(mDNS *m) |
| 5636 | { |
| 5637 | DNSQuestion *q; |
| 5638 | for (q = m->Questions; q; q = q->next) |
| 5639 | if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->state == LLQ_Established) |
| 5640 | { q->ReqLease = 0; sendLLQRefresh(m, q); } |
| 5641 | } |
| 5642 | #endif // UNICAST_DISABLED |
| 5643 | |
| 5644 | mDNSlocal mDNSBool QuestionHasLocalAnswers(mDNS *const m, DNSQuestion *q) |
| 5645 | { |
| 5646 | AuthRecord *rr; |
| 5647 | AuthGroup *ag; |
| 5648 | |
| 5649 | ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); |
| 5650 | if (ag) |
| 5651 | { |
| 5652 | for (rr = ag->members; rr; rr=rr->next) |
| 5653 | // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME |
| 5654 | if (UniqueLocalOnlyRecord(rr) && LocalOnlyRecordAnswersQuestion(rr, q)) |
| 5655 | { |
| 5656 | LogInfo("QuestionHasLocalAnswers: Question %p %##s (%s) has local answer %s" , q, q->qname.c, DNSTypeName(q->qtype), ARDisplayString(m, rr)); |
| 5657 | return mDNStrue; |
| 5658 | } |
| 5659 | } |
| 5660 | return mDNSfalse; |
| 5661 | } |
| 5662 | |
| 5663 | // ActivateUnicastQuery() is called from three places: |
| 5664 | // 1. When a new question is created |
| 5665 | // 2. On wake from sleep |
| 5666 | // 3. When the DNS configuration changes |
| 5667 | // In case 1 we don't want to mess with our established ThisQInterval and LastQTime (ScheduleImmediately is false) |
| 5668 | // In cases 2 and 3 we do want to cause the question to be resent immediately (ScheduleImmediately is true) |
| 5669 | mDNSlocal void ActivateUnicastQuery(mDNS *const m, DNSQuestion *const question, mDNSBool ScheduleImmediately) |
| 5670 | { |
| 5671 | // For now this AutoTunnel stuff is specific to Mac OS X. |
| 5672 | // In the future, if there's demand, we may see if we can abstract it out cleanly into the platform layer |
| 5673 | #if APPLE_OSX_mDNSResponder |
| 5674 | // Even though BTMM client tunnels are only useful for AAAA queries, we need to treat v4 and v6 queries equally. |
| 5675 | // Otherwise we can get the situation where the A query completes really fast (with an NXDOMAIN result) and the |
| 5676 | // caller then gives up waiting for the AAAA result while we're still in the process of setting up the tunnel. |
| 5677 | // To level the playing field, we block both A and AAAA queries while tunnel setup is in progress, and then |
| 5678 | // returns results for both at the same time. If we are looking for the _autotunnel6 record, then skip this logic |
| 5679 | // as this would trigger looking up _autotunnel6._autotunnel6 and end up failing the original query. |
| 5680 | |
| 5681 | if (RRTypeIsAddressType(question->qtype) && PrivateQuery(question) && |
| 5682 | !SameDomainLabel(question->qname.c, (const mDNSu8 *)"\x0c_autotunnel6" )&& question->QuestionCallback != AutoTunnelCallback) |
| 5683 | { |
| 5684 | question->NoAnswer = NoAnswer_Suspended; |
| 5685 | AddNewClientTunnel(question); |
| 5686 | return; |
| 5687 | } |
| 5688 | #endif // APPLE_OSX_mDNSResponder |
| 5689 | |
| 5690 | if (!question->DuplicateOf) |
| 5691 | { |
| 5692 | debugf("ActivateUnicastQuery: %##s %s%s%s" , |
| 5693 | question->qname.c, DNSTypeName(question->qtype), PrivateQuery(question) ? " (Private)" : "" , ScheduleImmediately ? " ScheduleImmediately" : "" ); |
| 5694 | question->CNAMEReferrals = 0; |
| 5695 | if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; } |
| 5696 | if (question->LongLived) |
| 5697 | { |
| 5698 | question->state = LLQ_InitialRequest; |
| 5699 | question->id = zeroOpaque64; |
| 5700 | question->servPort = zeroIPPort; |
| 5701 | if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; } |
| 5702 | } |
| 5703 | // If the question has local answers, then we don't want answers from outside |
| 5704 | if (ScheduleImmediately && !QuestionHasLocalAnswers(m, question)) |
| 5705 | { |
| 5706 | question->ThisQInterval = InitialQuestionInterval; |
| 5707 | question->LastQTime = m->timenow - question->ThisQInterval; |
| 5708 | SetNextQueryTime(m, question); |
| 5709 | } |
| 5710 | } |
| 5711 | } |
| 5712 | |
| 5713 | // Caller should hold the lock |
| 5714 | mDNSexport void mDNSCoreRestartAddressQueries(mDNS *const m, mDNSBool SearchDomainsChanged, FlushCache flushCacheRecords, |
| 5715 | CallbackBeforeStartQuery BeforeStartCallback, void *context) |
| 5716 | { |
| 5717 | DNSQuestion *q; |
| 5718 | DNSQuestion *restart = mDNSNULL; |
| 5719 | |
| 5720 | mDNS_CheckLock(m); |
| 5721 | |
| 5722 | // 1. Flush the cache records |
| 5723 | if (flushCacheRecords) flushCacheRecords(m); |
| 5724 | |
| 5725 | // 2. Even though we may have purged the cache records above, before it can generate RMV event |
| 5726 | // we are going to stop the question. Hence we need to deliver the RMV event before we |
| 5727 | // stop the question. |
| 5728 | // |
| 5729 | // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the |
| 5730 | // application callback can potentially stop the current question (detected by CurrentQuestion) or |
| 5731 | // *any* other question which could be the next one that we may process here. RestartQuestion |
| 5732 | // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal |
| 5733 | // if the "next" question is stopped while the CurrentQuestion is stopped |
| 5734 | |
| 5735 | if (m->RestartQuestion) |
| 5736 | LogMsg("mDNSCoreRestartAddressQueries: ERROR!! m->RestartQuestion already set: %##s (%s)" , |
| 5737 | m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); |
| 5738 | |
| 5739 | m->RestartQuestion = m->Questions; |
| 5740 | while (m->RestartQuestion) |
| 5741 | { |
| 5742 | q = m->RestartQuestion; |
| 5743 | m->RestartQuestion = q->next; |
| 5744 | // GetZoneData questions are referenced by other questions (original query that started the GetZoneData |
| 5745 | // question) through their "nta" pointer. Normally when the original query stops, it stops the |
| 5746 | // GetZoneData question and also frees the memory (See CancelGetZoneData). If we stop the GetZoneData |
| 5747 | // question followed by the original query that refers to this GetZoneData question, we will end up |
| 5748 | // freeing the GetZoneData question and then start the "freed" question at the end. |
| 5749 | |
| 5750 | if (IsGetZoneDataQuestion(q)) |
| 5751 | { |
| 5752 | DNSQuestion *refq = q->next; |
| 5753 | LogInfo("mDNSCoreRestartAddressQueries: Skipping GetZoneDataQuestion %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 5754 | // debug stuff, we just try to find the referencing question and don't do much with it |
| 5755 | while (refq) |
| 5756 | { |
| 5757 | if (q == &refq->nta->question) |
| 5758 | { |
| 5759 | LogInfo("mDNSCoreRestartAddressQueries: Question %p %##s (%s) referring to GetZoneDataQuestion %p, not stopping" , refq, refq->qname.c, DNSTypeName(refq->qtype), q); |
| 5760 | } |
| 5761 | refq = refq->next; |
| 5762 | } |
| 5763 | continue; |
| 5764 | } |
| 5765 | |
| 5766 | // This function is called when /etc/hosts changes and that could affect A, AAAA and CNAME queries |
| 5767 | if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA && q->qtype != kDNSType_CNAME) continue; |
| 5768 | |
| 5769 | // If the search domains did not change, then we restart all the queries. Otherwise, only |
| 5770 | // for queries for which we "might" have appended search domains ("might" because we may |
| 5771 | // find results before we apply search domains even though AppendSearchDomains is set to 1) |
| 5772 | if (!SearchDomainsChanged || q->AppendSearchDomains) |
| 5773 | { |
| 5774 | // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero |
| 5775 | // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before |
| 5776 | // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers). Let us say that |
| 5777 | // /etc/hosts has an A Record for web.apple.com. Any queries for web.apple.com will be answered locally. |
| 5778 | // But this can't prevent a CNAME/AAAA query to not to be sent on the wire. When it is sent on the wire, |
| 5779 | // it could create cache entries. When we are restarting queries, we can't deliver the cache RMV events |
| 5780 | // for the original query using these cache entries as ADDs were never delivered using these cache |
| 5781 | // entries and hence this order is needed. |
| 5782 | |
| 5783 | // If the query is suppressed, the RMV events won't be delivered |
| 5784 | if (!CacheRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Cache Record RMV events" ); continue; } |
| 5785 | |
| 5786 | // SuppressQuery status does not affect questions that are answered using local records |
| 5787 | if (!LocalRecordRmvEventsForQuestion(m, q)) { LogInfo("mDNSCoreRestartAddressQueries: Question deleted while delivering Local Record RMV events" ); continue; } |
| 5788 | |
| 5789 | LogInfo("mDNSCoreRestartAddressQueries: Stop question %p %##s (%s), AppendSearchDomains %d, qnameOrig %p" , q, |
| 5790 | q->qname.c, DNSTypeName(q->qtype), q->AppendSearchDomains, q->qnameOrig); |
| 5791 | mDNS_StopQuery_internal(m, q); |
| 5792 | // Reset state so that it looks like it was in the beginning i.e it should look at /etc/hosts, cache |
| 5793 | // and then search domains should be appended. At the beginning, qnameOrig was NULL. |
| 5794 | if (q->qnameOrig) |
| 5795 | { |
| 5796 | LogInfo("mDNSCoreRestartAddressQueries: qnameOrig %##s" , q->qnameOrig); |
| 5797 | AssignDomainName(&q->qname, q->qnameOrig); |
| 5798 | mDNSPlatformMemFree(q->qnameOrig); |
| 5799 | q->qnameOrig = mDNSNULL; |
| 5800 | q->RetryWithSearchDomains = ApplySearchDomainsFirst(q) ? 1 : 0; |
| 5801 | } |
| 5802 | q->SearchListIndex = 0; |
| 5803 | q->next = restart; |
| 5804 | restart = q; |
| 5805 | } |
| 5806 | } |
| 5807 | |
| 5808 | // 3. Callback before we start the query |
| 5809 | if (BeforeStartCallback) BeforeStartCallback(m, context); |
| 5810 | |
| 5811 | // 4. Restart all the stopped queries |
| 5812 | while (restart) |
| 5813 | { |
| 5814 | q = restart; |
| 5815 | restart = restart->next; |
| 5816 | q->next = mDNSNULL; |
| 5817 | LogInfo("mDNSCoreRestartAddressQueries: Start question %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 5818 | mDNS_StartQuery_internal(m, q); |
| 5819 | } |
| 5820 | } |
| 5821 | |
| 5822 | mDNSexport void mDNSCoreRestartQueries(mDNS *const m) |
| 5823 | { |
| 5824 | DNSQuestion *q; |
| 5825 | |
| 5826 | #ifndef UNICAST_DISABLED |
| 5827 | // Retrigger all our uDNS questions |
| 5828 | if (m->CurrentQuestion) |
| 5829 | LogMsg("mDNSCoreRestartQueries: ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 5830 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 5831 | m->CurrentQuestion = m->Questions; |
| 5832 | while (m->CurrentQuestion) |
| 5833 | { |
| 5834 | q = m->CurrentQuestion; |
| 5835 | m->CurrentQuestion = m->CurrentQuestion->next; |
| 5836 | if (!mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) ActivateUnicastQuery(m, q, mDNStrue); |
| 5837 | } |
| 5838 | #endif |
| 5839 | |
| 5840 | // Retrigger all our mDNS questions |
| 5841 | for (q = m->Questions; q; q=q->next) // Scan our list of questions |
| 5842 | mDNSCoreRestartQuestion(m, q); |
| 5843 | } |
| 5844 | |
| 5845 | // restart question if it's multicast and currently active |
| 5846 | mDNSexport void mDNSCoreRestartQuestion(mDNS *const m, DNSQuestion *q) |
| 5847 | { |
| 5848 | if (mDNSOpaque16IsZero(q->TargetQID) && ActiveQuestion(q)) |
| 5849 | { |
| 5850 | q->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question |
| 5851 | q->RequestUnicast = kDefaultRequestUnicastCount; |
| 5852 | q->LastQTime = m->timenow - q->ThisQInterval; |
| 5853 | q->RecentAnswerPkts = 0; |
| 5854 | ExpireDupSuppressInfo(q->DupSuppress, m->timenow); |
| 5855 | m->NextScheduledQuery = m->timenow; |
| 5856 | } |
| 5857 | } |
| 5858 | |
| 5859 | // restart the probe/announce cycle for multicast record |
| 5860 | mDNSexport void mDNSCoreRestartRegistration(mDNS *const m, AuthRecord *rr, int announceCount) |
| 5861 | { |
| 5862 | if (!AuthRecord_uDNS(rr)) |
| 5863 | { |
| 5864 | if (rr->resrec.RecordType == kDNSRecordTypeVerified && !rr->DependentOn) rr->resrec.RecordType = kDNSRecordTypeUnique; |
| 5865 | rr->ProbeCount = DefaultProbeCountForRecordType(rr->resrec.RecordType); |
| 5866 | |
| 5867 | if (mDNS_KeepaliveRecord(&rr->resrec)) |
| 5868 | { |
| 5869 | rr->AnnounceCount = 0; // Do not announce keepalive records |
| 5870 | } |
| 5871 | else |
| 5872 | { |
| 5873 | // announceCount < 0 indicates default announce count should be used |
| 5874 | if (announceCount < 0) |
| 5875 | announceCount = InitialAnnounceCount; |
| 5876 | if (rr->AnnounceCount < (mDNSu8)announceCount) |
| 5877 | rr->AnnounceCount = (mDNSu8)announceCount; |
| 5878 | } |
| 5879 | |
| 5880 | rr->SendNSECNow = mDNSNULL; |
| 5881 | InitializeLastAPTime(m, rr); |
| 5882 | } |
| 5883 | } |
| 5884 | |
| 5885 | // *************************************************************************** |
| 5886 | #if COMPILER_LIKES_PRAGMA_MARK |
| 5887 | #pragma mark - |
| 5888 | #pragma mark - Power Management (Sleep/Wake) |
| 5889 | #endif |
| 5890 | |
| 5891 | mDNSexport void mDNS_UpdateAllowSleep(mDNS *const m) |
| 5892 | { |
| 5893 | #ifndef IDLESLEEPCONTROL_DISABLED |
| 5894 | mDNSBool allowSleep = mDNStrue; |
| 5895 | char reason[128]; |
| 5896 | |
| 5897 | reason[0] = 0; |
| 5898 | |
| 5899 | if (m->SystemSleepOnlyIfWakeOnLAN) |
| 5900 | { |
| 5901 | // Don't sleep if we are a proxy for any services |
| 5902 | if (m->ProxyRecords) |
| 5903 | { |
| 5904 | allowSleep = mDNSfalse; |
| 5905 | mDNS_snprintf(reason, sizeof(reason), "sleep proxy for %d records" , m->ProxyRecords); |
| 5906 | LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because we are proxying %d records" , m->ProxyRecords); |
| 5907 | } |
| 5908 | |
| 5909 | if (allowSleep && mDNSCoreHaveAdvertisedMulticastServices(m)) |
| 5910 | { |
| 5911 | // Scan the list of active interfaces |
| 5912 | NetworkInterfaceInfo *intf; |
| 5913 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 5914 | { |
| 5915 | if (intf->McastTxRx && !intf->Loopback && !mDNSPlatformInterfaceIsD2D(intf->InterfaceID)) |
| 5916 | { |
| 5917 | // Disallow sleep if this interface doesn't support NetWake |
| 5918 | if (!intf->NetWake) |
| 5919 | { |
| 5920 | allowSleep = mDNSfalse; |
| 5921 | mDNS_snprintf(reason, sizeof(reason), "%s does not support NetWake" , intf->ifname); |
| 5922 | LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s does not support NetWake" , intf->ifname); |
| 5923 | break; |
| 5924 | } |
| 5925 | |
| 5926 | // If the interface can be an in-NIC Proxy, we should check if it can accomodate all the records |
| 5927 | // that will be offloaded. If not, we should prevent sleep. |
| 5928 | // This check will be possible once the lower layers provide an API to query the space available for offloads on the NIC. |
| 5929 | #if APPLE_OSX_mDNSResponder |
| 5930 | if (!SupportsInNICProxy(intf)) |
| 5931 | #endif |
| 5932 | { |
| 5933 | // Disallow sleep if there is no sleep proxy server |
| 5934 | const CacheRecord *cr = FindSPSInCache1(m, &intf->NetWakeBrowse, mDNSNULL, mDNSNULL); |
| 5935 | if ( cr == mDNSNULL) |
| 5936 | { |
| 5937 | allowSleep = mDNSfalse; |
| 5938 | mDNS_snprintf(reason, sizeof(reason), "No sleep proxy server on %s" , intf->ifname); |
| 5939 | LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s has no sleep proxy server" , intf->ifname); |
| 5940 | break; |
| 5941 | } |
| 5942 | else if (m->SPSType != 0) |
| 5943 | { |
| 5944 | mDNSu32 mymetric = LocalSPSMetric(m); |
| 5945 | mDNSu32 metric = SPSMetric(cr->resrec.rdata->u.name.c); |
| 5946 | if (metric >= mymetric) |
| 5947 | { |
| 5948 | allowSleep = mDNSfalse; |
| 5949 | mDNS_snprintf(reason, sizeof(reason), "No sleep proxy server with better metric on %s" , intf->ifname); |
| 5950 | LogInfo("mDNS_UpdateAllowSleep: Sleep disabled because %s has no sleep proxy server with a better metric" , intf->ifname); |
| 5951 | break; |
| 5952 | } |
| 5953 | } |
| 5954 | } |
| 5955 | } |
| 5956 | } |
| 5957 | } |
| 5958 | } |
| 5959 | |
| 5960 | // Call the platform code to enable/disable sleep |
| 5961 | mDNSPlatformSetAllowSleep(allowSleep, reason); |
| 5962 | #else |
| 5963 | (void) m; |
| 5964 | #endif /* !defined(IDLESLEEPCONTROL_DISABLED) */ |
| 5965 | } |
| 5966 | |
| 5967 | mDNSlocal mDNSBool mDNSUpdateOkToSend(mDNS *const m, AuthRecord *rr, NetworkInterfaceInfo *const intf, mDNSu32 scopeid) |
| 5968 | { |
| 5969 | // If it is not a uDNS record, check to see if the updateid is zero. "updateid" is cleared when we have |
| 5970 | // sent the resource record on all the interfaces. If the update id is not zero, check to see if it is time |
| 5971 | // to send. |
| 5972 | if (AuthRecord_uDNS(rr) || (rr->AuthFlags & AuthFlagsWakeOnly) || mDNSOpaque16IsZero(rr->updateid) || |
| 5973 | m->timenow - (rr->LastAPTime + rr->ThisAPInterval) < 0) |
| 5974 | { |
| 5975 | return mDNSfalse; |
| 5976 | } |
| 5977 | |
| 5978 | // If we have a pending registration for "scopeid", it is ok to send the update on that interface. |
| 5979 | // If the scopeid is too big to check for validity, we don't check against updateIntID. When |
| 5980 | // we successfully update on all the interfaces (with whatever set in "rr->updateIntID"), we clear |
| 5981 | // updateid and we should have returned from above. |
| 5982 | // |
| 5983 | // Note: scopeid is the same as intf->InterfaceID. It is passed in so that we don't have to call the |
| 5984 | // platform function to extract the value from "intf" every time. |
| 5985 | |
| 5986 | if ((scopeid >= (sizeof(rr->updateIntID) * mDNSNBBY) || bit_get_opaque64(rr->updateIntID, scopeid)) && |
| 5987 | (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID)) |
| 5988 | return mDNStrue; |
| 5989 | |
| 5990 | return mDNSfalse; |
| 5991 | } |
| 5992 | |
| 5993 | mDNSexport void UpdateRMAC(mDNS *const m, void *context) |
| 5994 | { |
| 5995 | IPAddressMACMapping *addrmap = (IPAddressMACMapping *)context ; |
| 5996 | m->CurrentRecord = m->ResourceRecords; |
| 5997 | |
| 5998 | if (!addrmap) |
| 5999 | { |
| 6000 | LogMsg("UpdateRMAC: Address mapping is NULL" ); |
| 6001 | return; |
| 6002 | } |
| 6003 | |
| 6004 | while (m->CurrentRecord) |
| 6005 | { |
| 6006 | AuthRecord *rr = m->CurrentRecord; |
| 6007 | // If this is a non-sleep proxy keepalive record and the remote IP address matches, update the RData |
| 6008 | if (!rr->WakeUp.HMAC.l[0] && mDNS_KeepaliveRecord(&rr->resrec)) |
| 6009 | { |
| 6010 | mDNSAddr raddr; |
| 6011 | getKeepaliveRaddr(m, rr, &raddr); |
| 6012 | if (mDNSSameAddress(&raddr, &addrmap->ipaddr)) |
| 6013 | { |
| 6014 | // Update the MAC address only if it is not a zero MAC address |
| 6015 | mDNSEthAddr macAddr; |
| 6016 | mDNSu8 *ptr = GetValueForMACAddr((mDNSu8 *)(addrmap->ethaddr), (mDNSu8 *) (addrmap->ethaddr + sizeof(addrmap->ethaddr)), &macAddr); |
| 6017 | if (ptr != mDNSNULL && !mDNSEthAddressIsZero(macAddr)) |
| 6018 | { |
| 6019 | UpdateKeepaliveRData(m, rr, mDNSNULL, mDNStrue, (char *)(addrmap->ethaddr)); |
| 6020 | } |
| 6021 | } |
| 6022 | } |
| 6023 | m->CurrentRecord = rr->next; |
| 6024 | } |
| 6025 | |
| 6026 | if (addrmap) |
| 6027 | mDNSPlatformMemFree(addrmap); |
| 6028 | |
| 6029 | } |
| 6030 | |
| 6031 | mDNSexport mStatus UpdateKeepaliveRData(mDNS *const m, AuthRecord *rr, NetworkInterfaceInfo *const intf, mDNSBool updateMac, char *ethAddr) |
| 6032 | { |
| 6033 | mDNSu16 newrdlength; |
| 6034 | mDNSAddr laddr = zeroAddr; |
| 6035 | mDNSAddr raddr = zeroAddr; |
| 6036 | mDNSEthAddr eth = zeroEthAddr; |
| 6037 | mDNSIPPort lport = zeroIPPort; |
| 6038 | mDNSIPPort rport = zeroIPPort; |
| 6039 | mDNSu32 timeout = 0; |
| 6040 | mDNSu32 seq = 0; |
| 6041 | mDNSu32 ack = 0; |
| 6042 | mDNSu16 win = 0; |
| 6043 | UTF8str255 txt; |
| 6044 | int rdsize; |
| 6045 | RData *newrd; |
| 6046 | mDNSTCPInfo mti; |
| 6047 | mStatus ret; |
| 6048 | |
| 6049 | // Note: If we fail to update the DNS NULL record with additional information in this function, it will be registered |
| 6050 | // with the SPS like any other record. SPS will not send keepalives if it does not have additional information. |
| 6051 | mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); |
| 6052 | if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport)) |
| 6053 | { |
| 6054 | LogMsg("UpdateKeepaliveRData: not a valid record %s for keepalive %#a:%d %#a:%d" , ARDisplayString(m, rr), &laddr, lport.NotAnInteger, &raddr, rport.NotAnInteger); |
| 6055 | return mStatus_UnknownErr; |
| 6056 | } |
| 6057 | |
| 6058 | if (updateMac) |
| 6059 | { |
| 6060 | if (laddr.type == mDNSAddrType_IPv4) |
| 6061 | newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d h=%#a d=%#a l=%u r=%u m=%s" , timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ethAddr); |
| 6062 | else |
| 6063 | newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d H=%#a D=%#a l=%u r=%u m=%s" , timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ethAddr); |
| 6064 | |
| 6065 | } |
| 6066 | else |
| 6067 | { |
| 6068 | // If this keepalive packet would be sent on a different interface than the current one that we are processing |
| 6069 | // now, then we don't update the DNS NULL record. But we do not prevent it from registering with the SPS. When SPS sees |
| 6070 | // this DNS NULL record, it does not send any keepalives as it does not have all the information |
| 6071 | mDNSPlatformMemZero(&mti, sizeof (mDNSTCPInfo)); |
| 6072 | ret = mDNSPlatformRetrieveTCPInfo(&laddr, &lport, &raddr, &rport, &mti); |
| 6073 | if (ret != mStatus_NoError) |
| 6074 | { |
| 6075 | LogMsg("mDNSPlatformRetrieveTCPInfo: mDNSPlatformRetrieveTCPInfo failed %d" , ret); |
| 6076 | return ret; |
| 6077 | } |
| 6078 | if ((intf != mDNSNULL) && (mti.IntfId != intf->InterfaceID)) |
| 6079 | { |
| 6080 | LogInfo("mDNSPlatformRetrieveTCPInfo: InterfaceID mismatch mti.IntfId = %p InterfaceID = %p" , mti.IntfId, intf->InterfaceID); |
| 6081 | return mStatus_BadParamErr; |
| 6082 | } |
| 6083 | |
| 6084 | if (laddr.type == mDNSAddrType_IPv4) |
| 6085 | newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d h=%#a d=%#a l=%u r=%u m=%.6a s=%u a=%u w=%u" , timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ð, mti.seq, mti.ack, mti.window); |
| 6086 | else |
| 6087 | newrdlength = mDNS_snprintf((char *)&txt.c[1], sizeof(txt.c) - 1, "t=%d i=%d c=%d H=%#a D=%#a l=%u r=%u m=%.6a s=%u a=%u w=%u" , timeout, kKeepaliveRetryInterval, kKeepaliveRetryCount, &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport), ð, mti.seq, mti.ack, mti.window); |
| 6088 | } |
| 6089 | |
| 6090 | // Did we insert a null byte at the end ? |
| 6091 | if (newrdlength == (sizeof(txt.c) - 1)) |
| 6092 | { |
| 6093 | LogMsg("UpdateKeepaliveRData: could not allocate memory %s" , ARDisplayString(m, rr)); |
| 6094 | return mStatus_NoMemoryErr; |
| 6095 | } |
| 6096 | |
| 6097 | // Include the length for the null byte at the end |
| 6098 | txt.c[0] = newrdlength + 1; |
| 6099 | // Account for the first length byte and the null byte at the end |
| 6100 | newrdlength += 2; |
| 6101 | |
| 6102 | rdsize = newrdlength > sizeof(RDataBody) ? newrdlength : sizeof(RDataBody); |
| 6103 | newrd = mDNSPlatformMemAllocate(sizeof(RData) - sizeof(RDataBody) + rdsize); |
| 6104 | if (!newrd) { LogMsg("UpdateKeepaliveRData: ptr NULL" ); return mStatus_NoMemoryErr; } |
| 6105 | |
| 6106 | newrd->MaxRDLength = (mDNSu16) rdsize; |
| 6107 | mDNSPlatformMemCopy(&newrd->u, txt.c, newrdlength); |
| 6108 | |
| 6109 | // If we are updating the record for the first time, rdata points to rdatastorage as the rdata memory |
| 6110 | // was allocated as part of the AuthRecord itself. We allocate memory when we update the AuthRecord. |
| 6111 | // If the resource record has data that we allocated in a previous pass (to update MAC address), |
| 6112 | // free that memory here before copying in the new data. |
| 6113 | if ( rr->resrec.rdata != &rr->rdatastorage) |
| 6114 | { |
| 6115 | LogSPS("UpdateKeepaliveRData: Freed allocated memory for keep alive packet: %s " , ARDisplayString(m, rr)); |
| 6116 | mDNSPlatformMemFree(rr->resrec.rdata); |
| 6117 | } |
| 6118 | SetNewRData(&rr->resrec, newrd, newrdlength); // Update our rdata |
| 6119 | |
| 6120 | LogSPS("UpdateKeepaliveRData: successfully updated the record %s" , ARDisplayString(m, rr)); |
| 6121 | return mStatus_NoError; |
| 6122 | } |
| 6123 | |
| 6124 | mDNSlocal void SendSPSRegistrationForOwner(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id, const OwnerOptData *const owner) |
| 6125 | { |
| 6126 | const int optspace = DNSOpt_Header_Space + DNSOpt_LeaseData_Space + DNSOpt_Owner_Space(&m->PrimaryMAC, &intf->MAC); |
| 6127 | const int sps = intf->NextSPSAttempt / 3; |
| 6128 | AuthRecord *rr; |
| 6129 | mDNSOpaque16 msgid; |
| 6130 | mDNSu32 scopeid; |
| 6131 | |
| 6132 | scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue); |
| 6133 | if (!intf->SPSAddr[sps].type) |
| 6134 | { |
| 6135 | intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond; |
| 6136 | if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0) |
| 6137 | m->NextScheduledSPRetry = intf->NextSPSAttemptTime; |
| 6138 | LogSPS("SendSPSRegistration: %s SPS %d (%d) %##s not yet resolved" , intf->ifname, intf->NextSPSAttempt, sps, intf->NetWakeResolve[sps].qname.c); |
| 6139 | goto exit; |
| 6140 | } |
| 6141 | |
| 6142 | // Mark our mDNS records (not unicast records) for transfer to SPS |
| 6143 | if (mDNSOpaque16IsZero(id)) |
| 6144 | { |
| 6145 | // We may have to register this record over multiple interfaces and we don't want to |
| 6146 | // overwrite the id. We send the registration over interface X with id "IDX" and before |
| 6147 | // we get a response, we overwrite with id "IDY" for interface Y and we won't accept responses |
| 6148 | // for "IDX". Hence, we want to use the same ID across all interfaces. |
| 6149 | // |
| 6150 | // In the case of sleep proxy server transfering its records when it goes to sleep, the owner |
| 6151 | // option check below will set the same ID across the records from the same owner. Records |
| 6152 | // with different owner option gets different ID. |
| 6153 | msgid = mDNS_NewMessageID(m); |
| 6154 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6155 | { |
| 6156 | if (!(rr->AuthFlags & AuthFlagsWakeOnly) && rr->resrec.RecordType > kDNSRecordTypeDeregistering) |
| 6157 | { |
| 6158 | if (rr->resrec.InterfaceID == intf->InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name)))) |
| 6159 | { |
| 6160 | if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner))) |
| 6161 | { |
| 6162 | rr->SendRNow = mDNSInterfaceMark; // mark it now |
| 6163 | // When we are registering on the first interface, rr->updateid is zero in which case |
| 6164 | // initialize with the new ID. For subsequent interfaces, we want to use the same ID. |
| 6165 | // At the end, all the updates sent across all the interfaces with the same ID. |
| 6166 | if (mDNSOpaque16IsZero(rr->updateid)) |
| 6167 | rr->updateid = msgid; |
| 6168 | else |
| 6169 | msgid = rr->updateid; |
| 6170 | } |
| 6171 | } |
| 6172 | } |
| 6173 | } |
| 6174 | } |
| 6175 | else |
| 6176 | msgid = id; |
| 6177 | |
| 6178 | while (1) |
| 6179 | { |
| 6180 | mDNSu8 *p = m->omsg.data; |
| 6181 | // To comply with RFC 2782, PutResourceRecord suppresses name compression for SRV records in unicast updates. |
| 6182 | // For now we follow that same logic for SPS registrations too. |
| 6183 | // If we decide to compress SRV records in SPS registrations in the future, we can achieve that by creating our |
| 6184 | // initial DNSMessage with h.flags set to zero, and then update it to UpdateReqFlags right before sending the packet. |
| 6185 | InitializeDNSMessage(&m->omsg.h, msgid, UpdateReqFlags); |
| 6186 | |
| 6187 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6188 | if (rr->SendRNow || mDNSUpdateOkToSend(m, rr, intf, scopeid)) |
| 6189 | { |
| 6190 | if (mDNSPlatformMemSame(owner, &rr->WakeUp, sizeof(*owner))) |
| 6191 | { |
| 6192 | mDNSu8 *newptr; |
| 6193 | const mDNSu8 *const limit = m->omsg.data + (m->omsg.h.mDNS_numUpdates ? NormalMaxDNSMessageData : AbsoluteMaxDNSMessageData) - optspace; |
| 6194 | |
| 6195 | // If we can't update the keepalive record, don't send it |
| 6196 | if (mDNS_KeepaliveRecord(&rr->resrec) && (UpdateKeepaliveRData(m, rr, intf, mDNSfalse, mDNSNULL) != mStatus_NoError)) |
| 6197 | { |
| 6198 | if (scopeid < (sizeof(rr->updateIntID) * mDNSNBBY)) |
| 6199 | { |
| 6200 | bit_clr_opaque64(rr->updateIntID, scopeid); |
| 6201 | } |
| 6202 | rr->SendRNow = mDNSNULL; |
| 6203 | continue; |
| 6204 | } |
| 6205 | |
| 6206 | if (rr->resrec.RecordType & kDNSRecordTypeUniqueMask) |
| 6207 | rr->resrec.rrclass |= kDNSClass_UniqueRRSet; // Temporarily set the 'unique' bit so PutResourceRecord will set it |
| 6208 | newptr = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.mDNS_numUpdates, &rr->resrec, rr->resrec.rroriginalttl, limit); |
| 6209 | rr->resrec.rrclass &= ~kDNSClass_UniqueRRSet; // Make sure to clear 'unique' bit back to normal state |
| 6210 | if (!newptr) |
| 6211 | LogSPS("SendSPSRegistration put %s FAILED %d/%d %s" , intf->ifname, p - m->omsg.data, limit - m->omsg.data, ARDisplayString(m, rr)); |
| 6212 | else |
| 6213 | { |
| 6214 | LogSPS("SendSPSRegistration put %s 0x%x 0x%x (updateid %d) %s" , intf->ifname, rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(m->omsg.h.id), ARDisplayString(m, rr)); |
| 6215 | rr->SendRNow = mDNSNULL; |
| 6216 | rr->ThisAPInterval = mDNSPlatformOneSecond; |
| 6217 | rr->LastAPTime = m->timenow; |
| 6218 | // should be initialized above |
| 6219 | if (mDNSOpaque16IsZero(rr->updateid)) LogMsg("SendSPSRegistration: ERROR!! rr %s updateid is zero" , ARDisplayString(m, rr)); |
| 6220 | if (m->NextScheduledResponse - (rr->LastAPTime + rr->ThisAPInterval) >= 0) |
| 6221 | m->NextScheduledResponse = (rr->LastAPTime + rr->ThisAPInterval); |
| 6222 | p = newptr; |
| 6223 | } |
| 6224 | } |
| 6225 | } |
| 6226 | |
| 6227 | if (!m->omsg.h.mDNS_numUpdates) break; |
| 6228 | else |
| 6229 | { |
| 6230 | AuthRecord opt; |
| 6231 | mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 6232 | opt.resrec.rrclass = NormalMaxDNSMessageData; |
| 6233 | opt.resrec.rdlength = sizeof(rdataOPT) * 2; // Two options in this OPT record |
| 6234 | opt.resrec.rdestimate = sizeof(rdataOPT) * 2; |
| 6235 | opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; |
| 6236 | opt.resrec.rdata->u.opt[0].optlen = DNSOpt_LeaseData_Space - 4; |
| 6237 | opt.resrec.rdata->u.opt[0].u.updatelease = DEFAULT_UPDATE_LEASE; |
| 6238 | if (!owner->HMAC.l[0]) // If no owner data, |
| 6239 | SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[1]); // use our own interface information |
| 6240 | else // otherwise, use the owner data we were given |
| 6241 | { |
| 6242 | opt.resrec.rdata->u.opt[1].u.owner = *owner; |
| 6243 | opt.resrec.rdata->u.opt[1].opt = kDNSOpt_Owner; |
| 6244 | opt.resrec.rdata->u.opt[1].optlen = DNSOpt_Owner_Space(&owner->HMAC, &owner->IMAC) - 4; |
| 6245 | } |
| 6246 | LogSPS("SendSPSRegistration put %s %s" , intf->ifname, ARDisplayString(m, &opt)); |
| 6247 | p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); |
| 6248 | if (!p) |
| 6249 | LogMsg("SendSPSRegistration: Failed to put OPT record (%d updates) %s" , m->omsg.h.mDNS_numUpdates, ARDisplayString(m, &opt)); |
| 6250 | else |
| 6251 | { |
| 6252 | mStatus err; |
| 6253 | |
| 6254 | LogSPS("SendSPSRegistration: Sending Update %s %d (%d) id %5d with %d records %d bytes to %#a:%d" , intf->ifname, intf->NextSPSAttempt, sps, |
| 6255 | mDNSVal16(m->omsg.h.id), m->omsg.h.mDNS_numUpdates, p - m->omsg.data, &intf->SPSAddr[sps], mDNSVal16(intf->SPSPort[sps])); |
| 6256 | // if (intf->NextSPSAttempt < 5) m->omsg.h.flags = zeroID; // For simulating packet loss |
| 6257 | err = mDNSSendDNSMessage(m, &m->omsg, p, intf->InterfaceID, mDNSNULL, &intf->SPSAddr[sps], intf->SPSPort[sps], mDNSNULL, mDNSNULL, mDNSfalse); |
| 6258 | if (err) LogSPS("SendSPSRegistration: mDNSSendDNSMessage err %d" , err); |
| 6259 | if (err && intf->SPSAddr[sps].type == mDNSAddrType_IPv4 && intf->NetWakeResolve[sps].ThisQInterval == -1) |
| 6260 | { |
| 6261 | LogSPS("SendSPSRegistration %d %##s failed to send to IPv4 address; will try IPv6 instead" , sps, intf->NetWakeResolve[sps].qname.c); |
| 6262 | intf->NetWakeResolve[sps].qtype = kDNSType_AAAA; |
| 6263 | mDNS_StartQuery_internal(m, &intf->NetWakeResolve[sps]); |
| 6264 | return; |
| 6265 | } |
| 6266 | } |
| 6267 | } |
| 6268 | } |
| 6269 | |
| 6270 | intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond * 10; // If successful, update NextSPSAttemptTime |
| 6271 | |
| 6272 | exit: |
| 6273 | if (mDNSOpaque16IsZero(id) && intf->NextSPSAttempt < 8) intf->NextSPSAttempt++; |
| 6274 | } |
| 6275 | |
| 6276 | mDNSlocal mDNSBool RecordIsFirstOccurrenceOfOwner(mDNS *const m, const AuthRecord *const rr) |
| 6277 | { |
| 6278 | AuthRecord *ar; |
| 6279 | for (ar = m->ResourceRecords; ar && ar != rr; ar=ar->next) |
| 6280 | if (mDNSPlatformMemSame(&rr->WakeUp, &ar->WakeUp, sizeof(rr->WakeUp))) return mDNSfalse; |
| 6281 | return mDNStrue; |
| 6282 | } |
| 6283 | |
| 6284 | mDNSlocal void mDNSCoreStoreProxyRR(mDNS *const m, const mDNSInterfaceID InterfaceID, AuthRecord *const rr) |
| 6285 | { |
| 6286 | AuthRecord *newRR = mDNSPlatformMemAllocate(sizeof(AuthRecord)); |
| 6287 | |
| 6288 | if (newRR == mDNSNULL) |
| 6289 | { |
| 6290 | LogSPS("%s : could not allocate memory for new resource record" , __func__); |
| 6291 | return; |
| 6292 | } |
| 6293 | |
| 6294 | mDNSPlatformMemZero(newRR, sizeof(AuthRecord)); |
| 6295 | mDNS_SetupResourceRecord(newRR, mDNSNULL, InterfaceID, rr->resrec.rrtype, |
| 6296 | rr->resrec.rroriginalttl, rr->resrec.RecordType, |
| 6297 | rr->ARType, mDNSNULL, mDNSNULL); |
| 6298 | |
| 6299 | AssignDomainName(&newRR->namestorage, &rr->namestorage); |
| 6300 | newRR->resrec.rdlength = DomainNameLength(rr->resrec.name); |
| 6301 | newRR->resrec.namehash = DomainNameHashValue(newRR->resrec.name); |
| 6302 | newRR->resrec.rrclass = rr->resrec.rrclass; |
| 6303 | |
| 6304 | if (rr->resrec.rrtype == kDNSType_A) |
| 6305 | { |
| 6306 | newRR->resrec.rdata->u.ipv4 = rr->resrec.rdata->u.ipv4; |
| 6307 | } |
| 6308 | else if (rr->resrec.rrtype == kDNSType_AAAA) |
| 6309 | { |
| 6310 | newRR->resrec.rdata->u.ipv6 = rr->resrec.rdata->u.ipv6; |
| 6311 | } |
| 6312 | SetNewRData(&newRR->resrec, mDNSNULL, 0); |
| 6313 | |
| 6314 | // Insert the new node at the head of the list. |
| 6315 | newRR->next = m->SPSRRSet; |
| 6316 | m->SPSRRSet = newRR; |
| 6317 | LogSPS("%s : Storing proxy record : %s " , __func__, ARDisplayString(m, rr)); |
| 6318 | } |
| 6319 | |
| 6320 | // Some records are interface specific and some are not. The ones that are supposed to be registered |
| 6321 | // on multiple interfaces need to be initialized with all the valid interfaces on which it will be sent. |
| 6322 | // updateIntID bit field tells us on which interfaces we need to register this record. When we get an |
| 6323 | // ack from the sleep proxy server, we clear the interface bit. This way, we know when a record completes |
| 6324 | // registration on all the interfaces |
| 6325 | mDNSlocal void SPSInitRecordsBeforeUpdate(mDNS *const m, mDNSOpaque64 updateIntID, mDNSBool *WakeOnlyService) |
| 6326 | { |
| 6327 | AuthRecord *ar; |
| 6328 | LogSPS("SPSInitRecordsBeforeUpdate: UpdateIntID 0x%x 0x%x" , updateIntID.l[1], updateIntID.l[0]); |
| 6329 | |
| 6330 | *WakeOnlyService = mDNSfalse; |
| 6331 | |
| 6332 | // Before we store the A and AAAA records that we are going to register with the sleep proxy, |
| 6333 | // make sure that the old sleep proxy records are removed. |
| 6334 | mDNSCoreFreeProxyRR(m); |
| 6335 | |
| 6336 | // For records that are registered only on a specific interface, mark only that bit as it will |
| 6337 | // never be registered on any other interface. For others, it should be sent on all interfaces. |
| 6338 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 6339 | { |
| 6340 | ar->updateIntID = zeroOpaque64; |
| 6341 | ar->updateid = zeroID; |
| 6342 | if (AuthRecord_uDNS(ar)) |
| 6343 | { |
| 6344 | continue; |
| 6345 | } |
| 6346 | if (ar->AuthFlags & AuthFlagsWakeOnly) |
| 6347 | { |
| 6348 | if (ar->resrec.RecordType == kDNSRecordTypeShared && ar->RequireGoodbye) |
| 6349 | { |
| 6350 | ar->ImmedAnswer = mDNSInterfaceMark; |
| 6351 | *WakeOnlyService = mDNStrue; |
| 6352 | continue; |
| 6353 | } |
| 6354 | } |
| 6355 | if (!ar->resrec.InterfaceID) |
| 6356 | { |
| 6357 | LogSPS("Setting scopeid (ALL) 0x%x 0x%x for %s" , updateIntID.l[1], updateIntID.l[0], ARDisplayString(m, ar)); |
| 6358 | ar->updateIntID = updateIntID; |
| 6359 | } |
| 6360 | else |
| 6361 | { |
| 6362 | // Filter records that belong to interfaces that we won't register the records on. UpdateIntID captures |
| 6363 | // exactly this. |
| 6364 | mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, ar->resrec.InterfaceID, mDNStrue); |
| 6365 | if ((scopeid < (sizeof(updateIntID) * mDNSNBBY)) && bit_get_opaque64(updateIntID, scopeid)) |
| 6366 | { |
| 6367 | bit_set_opaque64(ar->updateIntID, scopeid); |
| 6368 | LogSPS("SPSInitRecordsBeforeUpdate: Setting scopeid(%d) 0x%x 0x%x for %s" , scopeid, ar->updateIntID.l[1], |
| 6369 | ar->updateIntID.l[0], ARDisplayString(m, ar)); |
| 6370 | } |
| 6371 | else |
| 6372 | { |
| 6373 | LogSPS("SPSInitRecordsBeforeUpdate: scopeid %d beyond range or not valid for SPS registration" , scopeid); |
| 6374 | } |
| 6375 | } |
| 6376 | // Store the A and AAAA records that we registered with the sleep proxy. |
| 6377 | // We will use this to prevent spurious name conflicts that may occur when we wake up |
| 6378 | if (ar->resrec.rrtype == kDNSType_A || ar->resrec.rrtype == kDNSType_AAAA) |
| 6379 | { |
| 6380 | mDNSCoreStoreProxyRR(m, ar->resrec.InterfaceID, ar); |
| 6381 | } |
| 6382 | } |
| 6383 | } |
| 6384 | |
| 6385 | mDNSlocal void SendSPSRegistration(mDNS *const m, NetworkInterfaceInfo *const intf, const mDNSOpaque16 id) |
| 6386 | { |
| 6387 | AuthRecord *ar; |
| 6388 | OwnerOptData owner = zeroOwner; |
| 6389 | |
| 6390 | SendSPSRegistrationForOwner(m, intf, id, &owner); |
| 6391 | |
| 6392 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 6393 | { |
| 6394 | if (!mDNSPlatformMemSame(&owner, &ar->WakeUp, sizeof(owner)) && RecordIsFirstOccurrenceOfOwner(m, ar)) |
| 6395 | { |
| 6396 | owner = ar->WakeUp; |
| 6397 | SendSPSRegistrationForOwner(m, intf, id, &owner); |
| 6398 | } |
| 6399 | } |
| 6400 | } |
| 6401 | |
| 6402 | // RetrySPSRegistrations is called from SendResponses, with the lock held |
| 6403 | mDNSlocal void RetrySPSRegistrations(mDNS *const m) |
| 6404 | { |
| 6405 | AuthRecord *rr; |
| 6406 | NetworkInterfaceInfo *intf; |
| 6407 | |
| 6408 | // First make sure none of our interfaces' NextSPSAttemptTimes are inadvertently set to m->timenow + mDNSPlatformOneSecond * 10 |
| 6409 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 6410 | if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10) |
| 6411 | intf->NextSPSAttemptTime++; |
| 6412 | |
| 6413 | // Retry any record registrations that are due |
| 6414 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6415 | if (!AuthRecord_uDNS(rr) && !mDNSOpaque16IsZero(rr->updateid) && m->timenow - (rr->LastAPTime + rr->ThisAPInterval) >= 0) |
| 6416 | { |
| 6417 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 6418 | { |
| 6419 | // If we still have registrations pending on this interface, send it now |
| 6420 | mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue); |
| 6421 | if ((scopeid >= (sizeof(rr->updateIntID) * mDNSNBBY) || bit_get_opaque64(rr->updateIntID, scopeid)) && |
| 6422 | (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == intf->InterfaceID)) |
| 6423 | { |
| 6424 | LogSPS("RetrySPSRegistrations: 0x%x 0x%x (updateid %d) %s" , rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m, rr)); |
| 6425 | SendSPSRegistration(m, intf, rr->updateid); |
| 6426 | } |
| 6427 | } |
| 6428 | } |
| 6429 | |
| 6430 | // For interfaces where we did an SPS registration attempt, increment intf->NextSPSAttempt |
| 6431 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 6432 | if (intf->NextSPSAttempt && intf->NextSPSAttemptTime == m->timenow + mDNSPlatformOneSecond * 10 && intf->NextSPSAttempt < 8) |
| 6433 | intf->NextSPSAttempt++; |
| 6434 | } |
| 6435 | |
| 6436 | mDNSlocal void NetWakeResolve(mDNS *const m, DNSQuestion *question, const ResourceRecord *const answer, QC_result AddRecord) |
| 6437 | { |
| 6438 | NetworkInterfaceInfo *intf = (NetworkInterfaceInfo *)question->QuestionContext; |
| 6439 | int sps = (int)(question - intf->NetWakeResolve); |
| 6440 | (void)m; // Unused |
| 6441 | LogSPS("NetWakeResolve: SPS: %d Add: %d %s" , sps, AddRecord, RRDisplayString(m, answer)); |
| 6442 | |
| 6443 | if (!AddRecord) return; // Don't care about REMOVE events |
| 6444 | if (answer->rrtype != question->qtype) return; // Don't care about CNAMEs |
| 6445 | |
| 6446 | // if (answer->rrtype == kDNSType_AAAA && sps == 0) return; // To test failing to resolve sleep proxy's address |
| 6447 | |
| 6448 | if (answer->rrtype == kDNSType_SRV) |
| 6449 | { |
| 6450 | // 1. Got the SRV record; now look up the target host's IP address |
| 6451 | mDNS_StopQuery(m, question); |
| 6452 | intf->SPSPort[sps] = answer->rdata->u.srv.port; |
| 6453 | AssignDomainName(&question->qname, &answer->rdata->u.srv.target); |
| 6454 | question->qtype = kDNSType_A; |
| 6455 | mDNS_StartQuery(m, question); |
| 6456 | } |
| 6457 | else if (answer->rrtype == kDNSType_A && answer->rdlength == sizeof(mDNSv4Addr)) |
| 6458 | { |
| 6459 | // 2. Got an IPv4 address for the target host; record address and initiate an SPS registration if appropriate |
| 6460 | mDNS_StopQuery(m, question); |
| 6461 | question->ThisQInterval = -1; |
| 6462 | intf->SPSAddr[sps].type = mDNSAddrType_IPv4; |
| 6463 | intf->SPSAddr[sps].ip.v4 = answer->rdata->u.ipv4; |
| 6464 | mDNS_Lock(m); |
| 6465 | if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now |
| 6466 | mDNS_Unlock(m); |
| 6467 | } |
| 6468 | else if (answer->rrtype == kDNSType_A && answer->rdlength == 0) |
| 6469 | { |
| 6470 | // 3. Got negative response -- target host apparently has IPv6 disabled -- so try looking up the target host's IPv4 address(es) instead |
| 6471 | mDNS_StopQuery(m, question); |
| 6472 | LogSPS("NetWakeResolve: SPS %d %##s has no IPv4 address, will try IPv6 instead" , sps, question->qname.c); |
| 6473 | question->qtype = kDNSType_AAAA; |
| 6474 | mDNS_StartQuery(m, question); |
| 6475 | } |
| 6476 | else if (answer->rrtype == kDNSType_AAAA && answer->rdlength == sizeof(mDNSv6Addr) && mDNSv6AddressIsLinkLocal(&answer->rdata->u.ipv6)) |
| 6477 | { |
| 6478 | // 4. Got the target host's IPv6 link-local address; record address and initiate an SPS registration if appropriate |
| 6479 | mDNS_StopQuery(m, question); |
| 6480 | question->ThisQInterval = -1; |
| 6481 | intf->SPSAddr[sps].type = mDNSAddrType_IPv6; |
| 6482 | intf->SPSAddr[sps].ip.v6 = answer->rdata->u.ipv6; |
| 6483 | mDNS_Lock(m); |
| 6484 | if (sps == intf->NextSPSAttempt/3) SendSPSRegistration(m, intf, zeroID); // If we're ready for this result, use it now |
| 6485 | mDNS_Unlock(m); |
| 6486 | } |
| 6487 | } |
| 6488 | |
| 6489 | mDNSexport mDNSBool mDNSCoreHaveAdvertisedMulticastServices(mDNS *const m) |
| 6490 | { |
| 6491 | AuthRecord *rr; |
| 6492 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6493 | if (mDNS_KeepaliveRecord(&rr->resrec) || (rr->resrec.rrtype == kDNSType_SRV && !AuthRecord_uDNS(rr) && !mDNSSameIPPort(rr->resrec.rdata->u.srv.port, DiscardPort))) |
| 6494 | return mDNStrue; |
| 6495 | return mDNSfalse; |
| 6496 | } |
| 6497 | |
| 6498 | #define WAKE_ONLY_SERVICE 1 |
| 6499 | #define AC_ONLY_SERVICE 2 |
| 6500 | |
| 6501 | #ifdef APPLE_OSX_mDNSResponder |
| 6502 | mDNSlocal void SendGoodbyesForSelectServices(mDNS *const m, mDNSBool *servicePresent, mDNSu32 serviceType) |
| 6503 | { |
| 6504 | AuthRecord *rr; |
| 6505 | *servicePresent = mDNSfalse; |
| 6506 | |
| 6507 | // Mark all the records we need to deregister and send them |
| 6508 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6509 | { |
| 6510 | // If the service type is wake only service and the auth flags match and requires a goodbye |
| 6511 | // OR if the service type is AC only and it is not a keepalive record, |
| 6512 | // mark the records we need to deregister and send them |
| 6513 | if ((serviceType == WAKE_ONLY_SERVICE && (rr->AuthFlags & AuthFlagsWakeOnly) && |
| 6514 | rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) || |
| 6515 | (serviceType == AC_ONLY_SERVICE && !mDNS_KeepaliveRecord(&rr->resrec))) |
| 6516 | { |
| 6517 | rr->ImmedAnswer = mDNSInterfaceMark; |
| 6518 | *servicePresent = mDNStrue; |
| 6519 | } |
| 6520 | } |
| 6521 | } |
| 6522 | #endif |
| 6523 | |
| 6524 | #ifdef APPLE_OSX_mDNSResponder |
| 6525 | // This function is used only in the case of local NIC proxy. For external |
| 6526 | // sleep proxy server, we do this in SPSInitRecordsBeforeUpdate when we |
| 6527 | // walk the resource records. |
| 6528 | mDNSlocal void SendGoodbyesForWakeOnlyService(mDNS *const m, mDNSBool *WakeOnlyService) |
| 6529 | { |
| 6530 | return SendGoodbyesForSelectServices(m, WakeOnlyService, WAKE_ONLY_SERVICE); |
| 6531 | } |
| 6532 | #endif // APPLE_OSX_mDNSResponder |
| 6533 | |
| 6534 | |
| 6535 | mDNSlocal void SendSleepGoodbyes(mDNS *const m, mDNSBool AllInterfaces, mDNSBool unicast) |
| 6536 | { |
| 6537 | AuthRecord *rr; |
| 6538 | m->SleepState = SleepState_Sleeping; |
| 6539 | |
| 6540 | // If AllInterfaces is not set, the caller has already marked it appropriately |
| 6541 | // on which interfaces this should be sent. |
| 6542 | if (AllInterfaces) |
| 6543 | { |
| 6544 | NetworkInterfaceInfo *intf; |
| 6545 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 6546 | { |
| 6547 | intf->SendGoodbyes = 1; |
| 6548 | } |
| 6549 | } |
| 6550 | if (unicast) |
| 6551 | { |
| 6552 | #ifndef UNICAST_DISABLED |
| 6553 | SleepRecordRegistrations(m); // If we have no SPS, need to deregister our uDNS records |
| 6554 | #endif /* UNICAST_DISABLED */ |
| 6555 | } |
| 6556 | |
| 6557 | // Mark all the records we need to deregister and send them |
| 6558 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6559 | if (rr->resrec.RecordType == kDNSRecordTypeShared && rr->RequireGoodbye) |
| 6560 | rr->ImmedAnswer = mDNSInterfaceMark; |
| 6561 | SendResponses(m); |
| 6562 | } |
| 6563 | |
| 6564 | /* |
| 6565 | * This function attempts to detect if multiple interfaces are on the same subnet. |
| 6566 | * It makes this determination based only on the IPv4 Addresses and subnet masks. |
| 6567 | * IPv6 link local addresses that are configured by default on all interfaces make |
| 6568 | * it hard to make this determination |
| 6569 | * |
| 6570 | * The 'real' fix for this would be to send out multicast packets over one interface |
| 6571 | * and conclude that multiple interfaces are on the same subnet only if these packets |
| 6572 | * are seen on other interfaces on the same system |
| 6573 | */ |
| 6574 | mDNSlocal mDNSBool skipSameSubnetRegistration(mDNS *const m, mDNSInterfaceID *regID, mDNSu32 count, mDNSInterfaceID intfid) |
| 6575 | { |
| 6576 | NetworkInterfaceInfo *intf; |
| 6577 | NetworkInterfaceInfo *newIntf; |
| 6578 | mDNSu32 i; |
| 6579 | |
| 6580 | for (newIntf = FirstInterfaceForID(m, intfid); newIntf; newIntf = newIntf->next) |
| 6581 | { |
| 6582 | if ((newIntf->InterfaceID != intfid) || |
| 6583 | (newIntf->ip.type != mDNSAddrType_IPv4)) |
| 6584 | { |
| 6585 | continue; |
| 6586 | } |
| 6587 | for ( i = 0; i < count; i++) |
| 6588 | { |
| 6589 | for (intf = FirstInterfaceForID(m, regID[i]); intf; intf = intf->next) |
| 6590 | { |
| 6591 | if ((intf->InterfaceID != regID[i]) || |
| 6592 | (intf->ip.type != mDNSAddrType_IPv4)) |
| 6593 | { |
| 6594 | continue; |
| 6595 | } |
| 6596 | if ((intf->ip.ip.v4.NotAnInteger & intf->mask.ip.v4.NotAnInteger) == (newIntf->ip.ip.v4.NotAnInteger & newIntf->mask.ip.v4.NotAnInteger)) |
| 6597 | { |
| 6598 | LogSPS("%s : Already registered for the same subnet (IPv4) for interface %s" , __func__, intf->ifname); |
| 6599 | return (mDNStrue); |
| 6600 | } |
| 6601 | } |
| 6602 | } |
| 6603 | } |
| 6604 | return (mDNSfalse); |
| 6605 | } |
| 6606 | |
| 6607 | mDNSlocal void DoKeepaliveCallbacks(mDNS *m) |
| 6608 | { |
| 6609 | // Loop through the keepalive records and callback with an error |
| 6610 | m->CurrentRecord = m->ResourceRecords; |
| 6611 | while (m->CurrentRecord) |
| 6612 | { |
| 6613 | AuthRecord *const rr = m->CurrentRecord; |
| 6614 | if ((mDNS_KeepaliveRecord(&rr->resrec)) && (rr->resrec.RecordType != kDNSRecordTypeDeregistering)) |
| 6615 | { |
| 6616 | LogSPS("DoKeepaliveCallbacks: Invoking the callback for %s" , ARDisplayString(m, rr)); |
| 6617 | if (rr->RecordCallback) |
| 6618 | rr->RecordCallback(m, rr, mStatus_BadStateErr); |
| 6619 | } |
| 6620 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 6621 | m->CurrentRecord = rr->next; |
| 6622 | } |
| 6623 | } |
| 6624 | |
| 6625 | // BeginSleepProcessing is called, with the lock held, from either mDNS_Execute or mDNSCoreMachineSleep |
| 6626 | mDNSlocal void BeginSleepProcessing(mDNS *const m) |
| 6627 | { |
| 6628 | mDNSBool SendGoodbyes = mDNStrue; |
| 6629 | mDNSBool WakeOnlyService = mDNSfalse; |
| 6630 | mDNSBool invokeKACallback = mDNStrue; |
| 6631 | const CacheRecord *sps[3] = { mDNSNULL }; |
| 6632 | mDNSOpaque64 updateIntID = zeroOpaque64; |
| 6633 | mDNSInterfaceID registeredIntfIDS[128] = { 0 }; |
| 6634 | mDNSu32 registeredCount = 0; |
| 6635 | int skippedRegistrations = 0; |
| 6636 | |
| 6637 | m->NextScheduledSPRetry = m->timenow; |
| 6638 | |
| 6639 | // Clear out the SCDynamic entry that stores the external SPS information |
| 6640 | mDNSPlatformClearSPSData(); |
| 6641 | |
| 6642 | if (!m->SystemWakeOnLANEnabled) LogSPS("BeginSleepProcessing: m->SystemWakeOnLANEnabled is false" ); |
| 6643 | else if (!mDNSCoreHaveAdvertisedMulticastServices(m)) LogSPS("BeginSleepProcessing: No advertised services" ); |
| 6644 | else // If we have at least one advertised service |
| 6645 | { |
| 6646 | NetworkInterfaceInfo *intf; |
| 6647 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 6648 | { |
| 6649 | // Intialize it to false. These values make sense only when SleepState is set to Sleeping. |
| 6650 | intf->SendGoodbyes = 0; |
| 6651 | |
| 6652 | // If it is not multicast capable, we could not have possibly discovered sleep proxy |
| 6653 | // servers. |
| 6654 | if (!intf->McastTxRx || mDNSPlatformInterfaceIsD2D(intf->InterfaceID)) |
| 6655 | { |
| 6656 | LogSPS("BeginSleepProcessing: %-6s Ignoring for registrations" , intf->ifname); |
| 6657 | continue; |
| 6658 | } |
| 6659 | |
| 6660 | // If we are not capable of WOMP, then don't register with sleep proxy. |
| 6661 | // |
| 6662 | // Note: If we are not NetWake capable, we don't browse for the sleep proxy server. |
| 6663 | // We might find sleep proxy servers in the cache and start a resolve on them. |
| 6664 | // But then if the interface goes away, we won't stop these questions because |
| 6665 | // mDNS_DeactivateNetWake_internal assumes that a browse has been started for it |
| 6666 | // to stop both the browse and resolve questions. |
| 6667 | if (!intf->NetWake) |
| 6668 | { |
| 6669 | LogSPS("BeginSleepProcessing: %-6s not capable of magic packet wakeup" , intf->ifname); |
| 6670 | intf->SendGoodbyes = 1; |
| 6671 | skippedRegistrations++; |
| 6672 | continue; |
| 6673 | } |
| 6674 | |
| 6675 | // Check if we have already registered with a sleep proxy for this subnet |
| 6676 | if (skipSameSubnetRegistration(m, registeredIntfIDS, registeredCount, intf->InterfaceID)) |
| 6677 | { |
| 6678 | LogSPS("%s : Skipping sleep proxy registration on %s" , __func__, intf->ifname); |
| 6679 | continue; |
| 6680 | } |
| 6681 | |
| 6682 | #if APPLE_OSX_mDNSResponder |
| 6683 | else if (SupportsInNICProxy(intf)) |
| 6684 | { |
| 6685 | mDNSBool keepaliveOnly = mDNSfalse; |
| 6686 | if (ActivateLocalProxy(intf, &keepaliveOnly) == mStatus_NoError) |
| 6687 | { |
| 6688 | SendGoodbyesForWakeOnlyService(m, &WakeOnlyService); |
| 6689 | |
| 6690 | // Send goodbyes for all advertised services if the only record offloaded was the keepalive record. |
| 6691 | SendGoodbyes = (keepaliveOnly) ? mDNStrue: mDNSfalse; |
| 6692 | invokeKACallback = mDNSfalse; |
| 6693 | LogSPS("BeginSleepProcessing: %-6s using local proxy" , intf->ifname); |
| 6694 | // This will leave m->SleepState set to SleepState_Transferring, |
| 6695 | // which is okay because with no outstanding resolves, or updates in flight, |
| 6696 | // mDNSCoreReadyForSleep() will conclude correctly that all the updates have already completed |
| 6697 | |
| 6698 | // Setting this flag activates the SleepLimit which delays sleep by 5 seconds and |
| 6699 | // will allow the system to deregister any BTMM records. |
| 6700 | m->NextScheduledSPRetry = m->timenow + (5 * mDNSPlatformOneSecond); |
| 6701 | registeredIntfIDS[registeredCount] = intf->InterfaceID; |
| 6702 | registeredCount++; |
| 6703 | } |
| 6704 | } |
| 6705 | #endif // APPLE_OSX_mDNSResponder |
| 6706 | else |
| 6707 | { |
| 6708 | #if APPLE_OSX_mDNSResponder |
| 6709 | // If on battery, do not attempt to offload to external sleep proxies |
| 6710 | if (m->SystemWakeOnLANEnabled == mDNS_WakeOnBattery) |
| 6711 | { |
| 6712 | LogSPS("BegingSleepProcessing: Not connected to AC power - Not registering with an external sleep proxy." ); |
| 6713 | return; |
| 6714 | } |
| 6715 | #endif // APPLE_OSX_mDNSResponder |
| 6716 | FindSPSInCache(m, &intf->NetWakeBrowse, sps); |
| 6717 | if (!sps[0]) LogSPS("BeginSleepProcessing: %-6s %#a No Sleep Proxy Server found (Next Browse Q in %d, interval %d)" , |
| 6718 | intf->ifname, &intf->ip, NextQSendTime(&intf->NetWakeBrowse) - m->timenow, intf->NetWakeBrowse.ThisQInterval); |
| 6719 | else |
| 6720 | { |
| 6721 | int i; |
| 6722 | mDNSu32 scopeid; |
| 6723 | SendGoodbyes = mDNSfalse; |
| 6724 | intf->NextSPSAttempt = 0; |
| 6725 | intf->NextSPSAttemptTime = m->timenow + mDNSPlatformOneSecond; |
| 6726 | |
| 6727 | scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, intf->InterfaceID, mDNStrue); |
| 6728 | // Now we know for sure that we have to wait for registration to complete on this interface. |
| 6729 | if (scopeid < (sizeof(updateIntID) * mDNSNBBY)) |
| 6730 | bit_set_opaque64(updateIntID, scopeid); |
| 6731 | |
| 6732 | // Don't need to set m->NextScheduledSPRetry here because we already set "m->NextScheduledSPRetry = m->timenow" above |
| 6733 | for (i=0; i<3; i++) |
| 6734 | { |
| 6735 | #if ForceAlerts |
| 6736 | if (intf->SPSAddr[i].type) |
| 6737 | LogFatalError("BeginSleepProcessing: %s %d intf->SPSAddr[i].type %d" , intf->ifname, i, intf->SPSAddr[i].type); |
| 6738 | if (intf->NetWakeResolve[i].ThisQInterval >= 0) |
| 6739 | LogFatalError("BeginSleepProcessing: %s %d intf->NetWakeResolve[i].ThisQInterval %d" , intf->ifname, i, intf->NetWakeResolve[i].ThisQInterval); |
| 6740 | #endif |
| 6741 | intf->SPSAddr[i].type = mDNSAddrType_None; |
| 6742 | if (intf->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery(m, &intf->NetWakeResolve[i]); |
| 6743 | intf->NetWakeResolve[i].ThisQInterval = -1; |
| 6744 | if (sps[i]) |
| 6745 | { |
| 6746 | LogSPS("BeginSleepProcessing: %-6s Found Sleep Proxy Server %d TTL %d %s" , intf->ifname, i, sps[i]->resrec.rroriginalttl, CRDisplayString(m, sps[i])); |
| 6747 | mDNS_SetupQuestion(&intf->NetWakeResolve[i], intf->InterfaceID, &sps[i]->resrec.rdata->u.name, kDNSType_SRV, NetWakeResolve, intf); |
| 6748 | intf->NetWakeResolve[i].ReturnIntermed = mDNStrue; |
| 6749 | mDNS_StartQuery_internal(m, &intf->NetWakeResolve[i]); |
| 6750 | |
| 6751 | // If we are registering with a Sleep Proxy for a new subnet, add it to our list |
| 6752 | registeredIntfIDS[registeredCount] = intf->InterfaceID; |
| 6753 | registeredCount++; |
| 6754 | } |
| 6755 | } |
| 6756 | } |
| 6757 | } |
| 6758 | } |
| 6759 | } |
| 6760 | |
| 6761 | // If we have at least one interface on which we are registering with an external sleep proxy, |
| 6762 | // initialize all the records appropriately. |
| 6763 | if (!mDNSOpaque64IsZero(&updateIntID)) |
| 6764 | SPSInitRecordsBeforeUpdate(m, updateIntID, &WakeOnlyService); |
| 6765 | |
| 6766 | // Call the applicaitons that registered a keepalive record to inform them that we failed to offload |
| 6767 | // the records to a sleep proxy. |
| 6768 | if (invokeKACallback) |
| 6769 | { |
| 6770 | LogSPS("BeginSleepProcessing: Did not register with an in-NIC proxy - invoking the callbacks for KA records" ); |
| 6771 | DoKeepaliveCallbacks(m); |
| 6772 | } |
| 6773 | |
| 6774 | // SendSleepGoodbyes last two arguments control whether we send goodbyes on all |
| 6775 | // interfaces and also deregister unicast registrations. |
| 6776 | // |
| 6777 | // - If there are no sleep proxy servers, then send goodbyes on all interfaces |
| 6778 | // for both multicast and unicast. |
| 6779 | // |
| 6780 | // - If we skipped registrations on some interfaces, then we have already marked |
| 6781 | // them appropriately above. We don't need to send goodbyes for unicast as |
| 6782 | // we have registered with at least one sleep proxy. |
| 6783 | // |
| 6784 | // - If we are not planning to send any goodbyes, then check for WakeOnlyServices. |
| 6785 | // |
| 6786 | // Note: If we are planning to send goodbyes, we mark the record with mDNSInterfaceAny |
| 6787 | // and call SendResponses which inturn calls ShouldSendGoodbyesBeforeSleep which looks |
| 6788 | // at WakeOnlyServices first. |
| 6789 | if (SendGoodbyes) |
| 6790 | { |
| 6791 | LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server" ); |
| 6792 | SendSleepGoodbyes(m, mDNStrue, mDNStrue); |
| 6793 | } |
| 6794 | else if (skippedRegistrations) |
| 6795 | { |
| 6796 | LogSPS("BeginSleepProcessing: Not registering with Sleep Proxy Server on all interfaces" ); |
| 6797 | SendSleepGoodbyes(m, mDNSfalse, mDNSfalse); |
| 6798 | } |
| 6799 | else if (WakeOnlyService) |
| 6800 | { |
| 6801 | // If we saw WakeOnly service above, send the goodbyes now. |
| 6802 | LogSPS("BeginSleepProcessing: Sending goodbyes for WakeOnlyService" ); |
| 6803 | SendResponses(m); |
| 6804 | } |
| 6805 | } |
| 6806 | |
| 6807 | // Call mDNSCoreMachineSleep(m, mDNStrue) when the machine is about to go to sleep. |
| 6808 | // Call mDNSCoreMachineSleep(m, mDNSfalse) when the machine is has just woken up. |
| 6809 | // Normally, the platform support layer below mDNSCore should call this, not the client layer above. |
| 6810 | mDNSexport void mDNSCoreMachineSleep(mDNS *const m, mDNSBool sleep) |
| 6811 | { |
| 6812 | AuthRecord *rr; |
| 6813 | |
| 6814 | LogSPS("%s (old state %d) at %ld" , sleep ? "Sleeping" : "Waking" , m->SleepState, m->timenow); |
| 6815 | |
| 6816 | if (sleep && !m->SleepState) // Going to sleep |
| 6817 | { |
| 6818 | mDNS_Lock(m); |
| 6819 | // If we're going to sleep, need to stop advertising that we're a Sleep Proxy Server |
| 6820 | if (m->SPSSocket) |
| 6821 | { |
| 6822 | mDNSu8 oldstate = m->SPSState; |
| 6823 | mDNS_DropLockBeforeCallback(); // mDNS_DeregisterService expects to be called without the lock held, so we emulate that here |
| 6824 | m->SPSState = 2; |
| 6825 | #ifndef SPC_DISABLED |
| 6826 | if (oldstate == 1) mDNS_DeregisterService(m, &m->SPSRecords); |
| 6827 | #else |
| 6828 | (void)oldstate; |
| 6829 | #endif |
| 6830 | mDNS_ReclaimLockAfterCallback(); |
| 6831 | } |
| 6832 | |
| 6833 | m->SleepState = SleepState_Transferring; |
| 6834 | if (m->SystemWakeOnLANEnabled && m->DelaySleep) |
| 6835 | { |
| 6836 | // If we just woke up moments ago, allow ten seconds for networking to stabilize before going back to sleep |
| 6837 | LogSPS("mDNSCoreMachineSleep: Re-sleeping immediately after waking; will delay for %d ticks" , m->DelaySleep - m->timenow); |
| 6838 | m->SleepLimit = NonZeroTime(m->DelaySleep + mDNSPlatformOneSecond * 10); |
| 6839 | } |
| 6840 | else |
| 6841 | { |
| 6842 | m->DelaySleep = 0; |
| 6843 | m->SleepLimit = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 10); |
| 6844 | m->mDNSStats.Sleeps++; |
| 6845 | BeginSleepProcessing(m); |
| 6846 | } |
| 6847 | |
| 6848 | #ifndef UNICAST_DISABLED |
| 6849 | SuspendLLQs(m); |
| 6850 | #endif |
| 6851 | #if APPLE_OSX_mDNSResponder |
| 6852 | RemoveAutoTunnel6Record(m); |
| 6853 | #endif |
| 6854 | LogSPS("mDNSCoreMachineSleep: m->SleepState %d (%s) seq %d" , m->SleepState, |
| 6855 | m->SleepState == SleepState_Transferring ? "Transferring" : |
| 6856 | m->SleepState == SleepState_Sleeping ? "Sleeping" : "?" , m->SleepSeqNum); |
| 6857 | mDNS_Unlock(m); |
| 6858 | } |
| 6859 | else if (!sleep) // Waking up |
| 6860 | { |
| 6861 | mDNSu32 slot; |
| 6862 | CacheGroup *cg; |
| 6863 | CacheRecord *cr; |
| 6864 | NetworkInterfaceInfo *intf; |
| 6865 | mDNSs32 currtime, diff; |
| 6866 | |
| 6867 | mDNS_Lock(m); |
| 6868 | // Reset SleepLimit back to 0 now that we're awake again. |
| 6869 | m->SleepLimit = 0; |
| 6870 | |
| 6871 | // If we were previously sleeping, but now we're not, increment m->SleepSeqNum to indicate that we're entering a new period of wakefulness |
| 6872 | if (m->SleepState != SleepState_Awake) |
| 6873 | { |
| 6874 | m->SleepState = SleepState_Awake; |
| 6875 | m->SleepSeqNum++; |
| 6876 | // If the machine wakes and then immediately tries to sleep again (e.g. a maintenance wake) |
| 6877 | // then we enforce a minimum delay of five seconds before we begin sleep processing. |
| 6878 | // This is to allow time for the Ethernet link to come up, DHCP to get an address, mDNS to issue queries, etc., |
| 6879 | // before we make our determination of whether there's a Sleep Proxy out there we should register with. |
| 6880 | m->DelaySleep = NonZeroTime(m->timenow + kDarkWakeDelaySleep); |
| 6881 | } |
| 6882 | |
| 6883 | if (m->SPSState == 3) |
| 6884 | { |
| 6885 | m->SPSState = 0; |
| 6886 | mDNSCoreBeSleepProxyServer_internal(m, m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower, m->SPSFeatureFlags); |
| 6887 | } |
| 6888 | m->mDNSStats.Wakes++; |
| 6889 | m->DelayConflictProcessing = MAX_CONFLICT_PROCESSING_DELAYS; |
| 6890 | // ... and the same for NextSPSAttempt |
| 6891 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) intf->NextSPSAttempt = -1; |
| 6892 | |
| 6893 | // Restart unicast and multicast queries |
| 6894 | mDNSCoreRestartQueries(m); |
| 6895 | |
| 6896 | // and reactivtate service registrations |
| 6897 | m->NextSRVUpdate = NonZeroTime(m->timenow + mDNSPlatformOneSecond); |
| 6898 | LogInfo("mDNSCoreMachineSleep waking: NextSRVUpdate in %d %d" , m->NextSRVUpdate - m->timenow, m->timenow); |
| 6899 | |
| 6900 | // 2. Re-validate our cache records |
| 6901 | currtime = mDNSPlatformUTC(); |
| 6902 | |
| 6903 | diff = currtime - m->TimeSlept; |
| 6904 | FORALL_CACHERECORDS(slot, cg, cr) |
| 6905 | { |
| 6906 | // Temporary fix: For unicast cache records, look at how much time we slept. |
| 6907 | // Adjust the RecvTime by the amount of time we slept so that we age the |
| 6908 | // cache record appropriately. If it is expired already, purge. If there |
| 6909 | // is a network change that happens after the wakeup, we might purge the |
| 6910 | // cache anyways and this helps only in the case where there are no network |
| 6911 | // changes across sleep/wakeup transition. |
| 6912 | // |
| 6913 | // Note: If there is a network/DNS server change that already happened and |
| 6914 | // these cache entries are already refreshed and we are getting a delayed |
| 6915 | // wake up notification, we might adjust the TimeRcvd based on the time slept |
| 6916 | // now which can cause the cache to purge pre-maturely. As this is not a very |
| 6917 | // common case, this should happen rarely. |
| 6918 | if (!cr->resrec.InterfaceID) |
| 6919 | { |
| 6920 | if (diff > 0) |
| 6921 | { |
| 6922 | mDNSu32 uTTL = RRUnadjustedTTL(cr->resrec.rroriginalttl); |
| 6923 | const mDNSs32 remain = uTTL - (m->timenow - cr->TimeRcvd) / mDNSPlatformOneSecond; |
| 6924 | |
| 6925 | // -if we have slept longer than the remaining TTL, purge and start fresh. |
| 6926 | // -if we have been sleeping for a long time, we could reduce TimeRcvd below by |
| 6927 | // a sufficiently big value which could cause the value to go into the future |
| 6928 | // because of the signed comparison of time. For this to happen, we should have been |
| 6929 | // sleeping really long (~24 days). For now, we want to be conservative and flush even |
| 6930 | // if we have slept for more than two days. |
| 6931 | |
| 6932 | if (diff >= remain || diff > (2 * 24 * 3600)) |
| 6933 | { |
| 6934 | LogInfo("mDNSCoreMachineSleep: %s: Purging cache entry SleptTime %d, Remaining TTL %d" , |
| 6935 | CRDisplayString(m, cr), diff, remain); |
| 6936 | mDNS_PurgeCacheResourceRecord(m, cr); |
| 6937 | continue; |
| 6938 | } |
| 6939 | cr->TimeRcvd -= (diff * mDNSPlatformOneSecond); |
| 6940 | if (m->timenow - (cr->TimeRcvd + ((mDNSs32)uTTL * mDNSPlatformOneSecond)) >= 0) |
| 6941 | { |
| 6942 | LogInfo("mDNSCoreMachineSleep: %s: Purging after adjusting the remaining TTL %d by %d seconds" , |
| 6943 | CRDisplayString(m, cr), remain, diff); |
| 6944 | mDNS_PurgeCacheResourceRecord(m, cr); |
| 6945 | } |
| 6946 | else |
| 6947 | { |
| 6948 | LogInfo("mDNSCoreMachineSleep: %s: Adjusted the remain ttl %u by %d seconds" , CRDisplayString(m, cr), remain, diff); |
| 6949 | } |
| 6950 | } |
| 6951 | } |
| 6952 | else |
| 6953 | { |
| 6954 | mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForWake); |
| 6955 | } |
| 6956 | } |
| 6957 | |
| 6958 | // 3. Retrigger probing and announcing for all our authoritative records |
| 6959 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 6960 | { |
| 6961 | if (AuthRecord_uDNS(rr)) |
| 6962 | { |
| 6963 | ActivateUnicastRegistration(m, rr); |
| 6964 | } |
| 6965 | else |
| 6966 | { |
| 6967 | mDNSCoreRestartRegistration(m, rr, -1); |
| 6968 | } |
| 6969 | } |
| 6970 | |
| 6971 | // 4. Refresh NAT mappings |
| 6972 | // We don't want to have to assume that all hardware can necessarily keep accurate |
| 6973 | // track of passage of time while asleep, so on wake we refresh our NAT mappings. |
| 6974 | // We typically wake up with no interfaces active, so there's no need to rush to try to find our external address. |
| 6975 | // But if we do get a network configuration change, mDNSMacOSXNetworkChanged will call uDNS_SetupDNSConfig, which |
| 6976 | // will call mDNS_SetPrimaryInterfaceInfo, which will call RecreateNATMappings to refresh them, potentially sooner |
| 6977 | // than five seconds from now. |
| 6978 | LogInfo("mDNSCoreMachineSleep: recreating NAT mappings in 5 seconds" ); |
| 6979 | RecreateNATMappings(m, mDNSPlatformOneSecond * 5); |
| 6980 | mDNS_Unlock(m); |
| 6981 | } |
| 6982 | } |
| 6983 | |
| 6984 | mDNSexport mDNSBool mDNSCoreReadyForSleep(mDNS *m, mDNSs32 now) |
| 6985 | { |
| 6986 | DNSQuestion *q; |
| 6987 | AuthRecord *rr; |
| 6988 | NetworkInterfaceInfo *intf; |
| 6989 | |
| 6990 | mDNS_Lock(m); |
| 6991 | |
| 6992 | if (m->DelaySleep) goto notready; |
| 6993 | |
| 6994 | // If we've not hit the sleep limit time, and it's not time for our next retry, we can skip these checks |
| 6995 | if (m->SleepLimit - now > 0 && m->NextScheduledSPRetry - now > 0) goto notready; |
| 6996 | |
| 6997 | m->NextScheduledSPRetry = now + 0x40000000UL; |
| 6998 | |
| 6999 | // See if we might need to retransmit any lost Sleep Proxy Registrations |
| 7000 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 7001 | if (intf->NextSPSAttempt >= 0) |
| 7002 | { |
| 7003 | if (now - intf->NextSPSAttemptTime >= 0) |
| 7004 | { |
| 7005 | LogSPS("mDNSCoreReadyForSleep: retrying for %s SPS %d try %d" , |
| 7006 | intf->ifname, intf->NextSPSAttempt/3, intf->NextSPSAttempt); |
| 7007 | SendSPSRegistration(m, intf, zeroID); |
| 7008 | // Don't need to "goto notready" here, because if we do still have record registrations |
| 7009 | // that have not been acknowledged yet, we'll catch that in the record list scan below. |
| 7010 | } |
| 7011 | else |
| 7012 | if (m->NextScheduledSPRetry - intf->NextSPSAttemptTime > 0) |
| 7013 | m->NextScheduledSPRetry = intf->NextSPSAttemptTime; |
| 7014 | } |
| 7015 | |
| 7016 | // Scan list of interfaces, and see if we're still waiting for any sleep proxy resolves to complete |
| 7017 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 7018 | { |
| 7019 | int sps = (intf->NextSPSAttempt == 0) ? 0 : (intf->NextSPSAttempt-1)/3; |
| 7020 | if (intf->NetWakeResolve[sps].ThisQInterval >= 0) |
| 7021 | { |
| 7022 | LogSPS("mDNSCoreReadyForSleep: waiting for SPS Resolve %s %##s (%s)" , |
| 7023 | intf->ifname, intf->NetWakeResolve[sps].qname.c, DNSTypeName(intf->NetWakeResolve[sps].qtype)); |
| 7024 | goto spsnotready; |
| 7025 | } |
| 7026 | } |
| 7027 | |
| 7028 | // Scan list of registered records |
| 7029 | for (rr = m->ResourceRecords; rr; rr = rr->next) |
| 7030 | if (!AuthRecord_uDNS(rr)) |
| 7031 | if (!mDNSOpaque64IsZero(&rr->updateIntID)) |
| 7032 | { LogSPS("mDNSCoreReadyForSleep: waiting for SPS updateIntID 0x%x 0x%x (updateid %d) %s" , rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto spsnotready; } |
| 7033 | |
| 7034 | // Scan list of private LLQs, and make sure they've all completed their handshake with the server |
| 7035 | for (q = m->Questions; q; q = q->next) |
| 7036 | if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived && q->ReqLease == 0 && q->tcp) |
| 7037 | { |
| 7038 | LogSPS("mDNSCoreReadyForSleep: waiting for LLQ %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 7039 | goto notready; |
| 7040 | } |
| 7041 | |
| 7042 | // Scan list of registered records |
| 7043 | for (rr = m->ResourceRecords; rr; rr = rr->next) |
| 7044 | if (AuthRecord_uDNS(rr)) |
| 7045 | { |
| 7046 | if (rr->state == regState_Refresh && rr->tcp) |
| 7047 | { LogSPS("mDNSCoreReadyForSleep: waiting for Record updateIntID 0x%x 0x%x (updateid %d) %s" , rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); goto notready; } |
| 7048 | #if APPLE_OSX_mDNSResponder |
| 7049 | if (!RecordReadyForSleep(rr)) { LogSPS("mDNSCoreReadyForSleep: waiting for %s" , ARDisplayString(m, rr)); goto notready; } |
| 7050 | #endif |
| 7051 | } |
| 7052 | |
| 7053 | mDNS_Unlock(m); |
| 7054 | return mDNStrue; |
| 7055 | |
| 7056 | spsnotready: |
| 7057 | |
| 7058 | // If we failed to complete sleep proxy registration within ten seconds, we give up on that |
| 7059 | // and allow up to ten seconds more to complete wide-area deregistration instead |
| 7060 | if (now - m->SleepLimit >= 0) |
| 7061 | { |
| 7062 | LogMsg("Failed to register with SPS, now sending goodbyes" ); |
| 7063 | |
| 7064 | for (intf = GetFirstActiveInterface(m->HostInterfaces); intf; intf = GetFirstActiveInterface(intf->next)) |
| 7065 | if (intf->NetWakeBrowse.ThisQInterval >= 0) |
| 7066 | { |
| 7067 | LogSPS("ReadyForSleep mDNS_DeactivateNetWake %s %##s (%s)" , |
| 7068 | intf->ifname, intf->NetWakeResolve[0].qname.c, DNSTypeName(intf->NetWakeResolve[0].qtype)); |
| 7069 | mDNS_DeactivateNetWake_internal(m, intf); |
| 7070 | } |
| 7071 | |
| 7072 | for (rr = m->ResourceRecords; rr; rr = rr->next) |
| 7073 | if (!AuthRecord_uDNS(rr)) |
| 7074 | if (!mDNSOpaque64IsZero(&rr->updateIntID)) |
| 7075 | { |
| 7076 | LogSPS("ReadyForSleep clearing updateIntID 0x%x 0x%x (updateid %d) for %s" , rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m, rr)); |
| 7077 | rr->updateIntID = zeroOpaque64; |
| 7078 | } |
| 7079 | |
| 7080 | // We'd really like to allow up to ten seconds more here, |
| 7081 | // but if we don't respond to the sleep notification within 30 seconds |
| 7082 | // we'll be put back to sleep forcibly without the chance to schedule the next maintenance wake. |
| 7083 | // Right now we wait 16 sec after wake for all the interfaces to come up, then we wait up to 10 seconds |
| 7084 | // more for SPS resolves and record registrations to complete, which puts us at 26 seconds. |
| 7085 | // If we allow just one more second to send our goodbyes, that puts us at 27 seconds. |
| 7086 | m->SleepLimit = now + mDNSPlatformOneSecond * 1; |
| 7087 | |
| 7088 | SendSleepGoodbyes(m, mDNStrue, mDNStrue); |
| 7089 | } |
| 7090 | |
| 7091 | notready: |
| 7092 | mDNS_Unlock(m); |
| 7093 | return mDNSfalse; |
| 7094 | } |
| 7095 | |
| 7096 | mDNSexport mDNSs32 mDNSCoreIntervalToNextWake(mDNS *const m, mDNSs32 now) |
| 7097 | { |
| 7098 | AuthRecord *ar; |
| 7099 | |
| 7100 | // Even when we have no wake-on-LAN-capable interfaces, or we failed to find a sleep proxy, or we have other |
| 7101 | // failure scenarios, we still want to wake up in at most 120 minutes, to see if the network environment has changed. |
| 7102 | // E.g. we might wake up and find no wireless network because the base station got rebooted just at that moment, |
| 7103 | // and if that happens we don't want to just give up and go back to sleep and never try again. |
| 7104 | mDNSs32 e = now + (120 * 60 * mDNSPlatformOneSecond); // Sleep for at most 120 minutes |
| 7105 | |
| 7106 | NATTraversalInfo *nat; |
| 7107 | for (nat = m->NATTraversals; nat; nat=nat->next) |
| 7108 | if (nat->Protocol && nat->ExpiryTime && nat->ExpiryTime - now > mDNSPlatformOneSecond*4) |
| 7109 | { |
| 7110 | mDNSs32 t = nat->ExpiryTime - (nat->ExpiryTime - now) / 10; // Wake up when 90% of the way to the expiry time |
| 7111 | if (e - t > 0) e = t; |
| 7112 | LogSPS("ComputeWakeTime: %p %s Int %5d Ext %5d Err %d Retry %5d Interval %5d Expire %5d Wake %5d" , |
| 7113 | nat, nat->Protocol == NATOp_MapTCP ? "TCP" : "UDP" , |
| 7114 | mDNSVal16(nat->IntPort), mDNSVal16(nat->ExternalPort), nat->Result, |
| 7115 | nat->retryPortMap ? (nat->retryPortMap - now) / mDNSPlatformOneSecond : 0, |
| 7116 | nat->retryInterval / mDNSPlatformOneSecond, |
| 7117 | nat->ExpiryTime ? (nat->ExpiryTime - now) / mDNSPlatformOneSecond : 0, |
| 7118 | (t - now) / mDNSPlatformOneSecond); |
| 7119 | } |
| 7120 | |
| 7121 | // This loop checks both the time we need to renew wide-area registrations, |
| 7122 | // and the time we need to renew Sleep Proxy registrations |
| 7123 | for (ar = m->ResourceRecords; ar; ar = ar->next) |
| 7124 | if (ar->expire && ar->expire - now > mDNSPlatformOneSecond*4) |
| 7125 | { |
| 7126 | mDNSs32 t = ar->expire - (ar->expire - now) / 10; // Wake up when 90% of the way to the expiry time |
| 7127 | if (e - t > 0) e = t; |
| 7128 | LogSPS("ComputeWakeTime: %p Int %7d Next %7d Expire %7d Wake %7d %s" , |
| 7129 | ar, ar->ThisAPInterval / mDNSPlatformOneSecond, |
| 7130 | (ar->LastAPTime + ar->ThisAPInterval - now) / mDNSPlatformOneSecond, |
| 7131 | ar->expire ? (ar->expire - now) / mDNSPlatformOneSecond : 0, |
| 7132 | (t - now) / mDNSPlatformOneSecond, ARDisplayString(m, ar)); |
| 7133 | } |
| 7134 | |
| 7135 | return(e - now); |
| 7136 | } |
| 7137 | |
| 7138 | // *************************************************************************** |
| 7139 | #if COMPILER_LIKES_PRAGMA_MARK |
| 7140 | #pragma mark - |
| 7141 | #pragma mark - Packet Reception Functions |
| 7142 | #endif |
| 7143 | |
| 7144 | #define MustSendRecord(RR) ((RR)->NR_AnswerTo || (RR)->NR_AdditionalTo) |
| 7145 | |
| 7146 | mDNSlocal mDNSu8 *GenerateUnicastResponse(const DNSMessage *const query, const mDNSu8 *const end, |
| 7147 | const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, DNSMessage *const response, AuthRecord *ResponseRecords) |
| 7148 | { |
| 7149 | mDNSu8 *responseptr = response->data; |
| 7150 | const mDNSu8 *const limit = response->data + sizeof(response->data); |
| 7151 | const mDNSu8 *ptr = query->data; |
| 7152 | AuthRecord *rr; |
| 7153 | mDNSu32 maxttl = 0x70000000; |
| 7154 | int i; |
| 7155 | |
| 7156 | // Initialize the response fields so we can answer the questions |
| 7157 | InitializeDNSMessage(&response->h, query->h.id, ResponseFlags); |
| 7158 | |
| 7159 | // *** |
| 7160 | // *** 1. Write out the list of questions we are actually going to answer with this packet |
| 7161 | // *** |
| 7162 | if (LegacyQuery) |
| 7163 | { |
| 7164 | maxttl = kStaticCacheTTL; |
| 7165 | for (i=0; i<query->h.numQuestions; i++) // For each question... |
| 7166 | { |
| 7167 | DNSQuestion q; |
| 7168 | ptr = getQuestion(query, ptr, end, InterfaceID, &q); // get the question... |
| 7169 | if (!ptr) return(mDNSNULL); |
| 7170 | |
| 7171 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) // and search our list of proposed answers |
| 7172 | { |
| 7173 | if (rr->NR_AnswerTo == ptr) // If we're going to generate a record answering this question |
| 7174 | { // then put the question in the question section |
| 7175 | responseptr = putQuestion(response, responseptr, limit, &q.qname, q.qtype, q.qclass); |
| 7176 | if (!responseptr) { debugf("GenerateUnicastResponse: Ran out of space for questions!" ); return(mDNSNULL); } |
| 7177 | break; // break out of the ResponseRecords loop, and go on to the next question |
| 7178 | } |
| 7179 | } |
| 7180 | } |
| 7181 | |
| 7182 | if (response->h.numQuestions == 0) { LogMsg("GenerateUnicastResponse: ERROR! Why no questions?" ); return(mDNSNULL); } |
| 7183 | } |
| 7184 | |
| 7185 | // *** |
| 7186 | // *** 2. Write Answers |
| 7187 | // *** |
| 7188 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) |
| 7189 | if (rr->NR_AnswerTo) |
| 7190 | { |
| 7191 | mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAnswers, &rr->resrec, |
| 7192 | maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl); |
| 7193 | if (p) responseptr = p; |
| 7194 | else { debugf("GenerateUnicastResponse: Ran out of space for answers!" ); response->h.flags.b[0] |= kDNSFlag0_TC; } |
| 7195 | } |
| 7196 | |
| 7197 | // *** |
| 7198 | // *** 3. Write Additionals |
| 7199 | // *** |
| 7200 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) |
| 7201 | if (rr->NR_AdditionalTo && !rr->NR_AnswerTo) |
| 7202 | { |
| 7203 | mDNSu8 *p = PutResourceRecordTTL(response, responseptr, &response->h.numAdditionals, &rr->resrec, |
| 7204 | maxttl < rr->resrec.rroriginalttl ? maxttl : rr->resrec.rroriginalttl); |
| 7205 | if (p) responseptr = p; |
| 7206 | else debugf("GenerateUnicastResponse: No more space for additionals" ); |
| 7207 | } |
| 7208 | |
| 7209 | return(responseptr); |
| 7210 | } |
| 7211 | |
| 7212 | // AuthRecord *our is our Resource Record |
| 7213 | // CacheRecord *pkt is the Resource Record from the response packet we've witnessed on the network |
| 7214 | // Returns 0 if there is no conflict |
| 7215 | // Returns +1 if there was a conflict and we won |
| 7216 | // Returns -1 if there was a conflict and we lost and have to rename |
| 7217 | mDNSlocal int CompareRData(const AuthRecord *const our, const CacheRecord *const pkt) |
| 7218 | { |
| 7219 | mDNSu8 ourdata[256], *ourptr = ourdata, *ourend; |
| 7220 | mDNSu8 pktdata[256], *pktptr = pktdata, *pktend; |
| 7221 | if (!our) { LogMsg("CompareRData ERROR: our is NULL" ); return(+1); } |
| 7222 | if (!pkt) { LogMsg("CompareRData ERROR: pkt is NULL" ); return(+1); } |
| 7223 | |
| 7224 | ourend = putRData(mDNSNULL, ourdata, ourdata + sizeof(ourdata), &our->resrec); |
| 7225 | pktend = putRData(mDNSNULL, pktdata, pktdata + sizeof(pktdata), &pkt->resrec); |
| 7226 | while (ourptr < ourend && pktptr < pktend && *ourptr == *pktptr) { ourptr++; pktptr++; } |
| 7227 | if (ourptr >= ourend && pktptr >= pktend) return(0); // If data identical, not a conflict |
| 7228 | |
| 7229 | if (ourptr >= ourend) return(-1); // Our data ran out first; We lost |
| 7230 | if (pktptr >= pktend) return(+1); // Packet data ran out first; We won |
| 7231 | if (*pktptr > *ourptr) return(-1); // Our data is numerically lower; We lost |
| 7232 | if (*pktptr < *ourptr) return(+1); // Packet data is numerically lower; We won |
| 7233 | |
| 7234 | LogMsg("CompareRData ERROR: Invalid state" ); |
| 7235 | return(-1); |
| 7236 | } |
| 7237 | |
| 7238 | // See if we have an authoritative record that's identical to this packet record, |
| 7239 | // whose canonical DependentOn record is the specified master record. |
| 7240 | // The DependentOn pointer is typically used for the TXT record of service registrations |
| 7241 | // It indicates that there is no inherent conflict detection for the TXT record |
| 7242 | // -- it depends on the SRV record to resolve name conflicts |
| 7243 | // If we find any identical ResourceRecords in our authoritative list, then follow their DependentOn |
| 7244 | // pointer chain (if any) to make sure we reach the canonical DependentOn record |
| 7245 | // If the record has no DependentOn, then just return that record's pointer |
| 7246 | // Returns NULL if we don't have any local RRs that are identical to the one from the packet |
| 7247 | mDNSlocal mDNSBool MatchDependentOn(const mDNS *const m, const CacheRecord *const pktrr, const AuthRecord *const master) |
| 7248 | { |
| 7249 | const AuthRecord *r1; |
| 7250 | for (r1 = m->ResourceRecords; r1; r1=r1->next) |
| 7251 | { |
| 7252 | if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec)) |
| 7253 | { |
| 7254 | const AuthRecord *r2 = r1; |
| 7255 | while (r2->DependentOn) r2 = r2->DependentOn; |
| 7256 | if (r2 == master) return(mDNStrue); |
| 7257 | } |
| 7258 | } |
| 7259 | for (r1 = m->DuplicateRecords; r1; r1=r1->next) |
| 7260 | { |
| 7261 | if (IdenticalResourceRecord(&r1->resrec, &pktrr->resrec)) |
| 7262 | { |
| 7263 | const AuthRecord *r2 = r1; |
| 7264 | while (r2->DependentOn) r2 = r2->DependentOn; |
| 7265 | if (r2 == master) return(mDNStrue); |
| 7266 | } |
| 7267 | } |
| 7268 | return(mDNSfalse); |
| 7269 | } |
| 7270 | |
| 7271 | // Find the canonical RRSet pointer for this RR received in a packet. |
| 7272 | // If we find any identical AuthRecord in our authoritative list, then follow its RRSet |
| 7273 | // pointers (if any) to make sure we return the canonical member of this name/type/class |
| 7274 | // Returns NULL if we don't have any local RRs that are identical to the one from the packet |
| 7275 | mDNSlocal const AuthRecord *FindRRSet(const mDNS *const m, const CacheRecord *const pktrr) |
| 7276 | { |
| 7277 | const AuthRecord *rr; |
| 7278 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 7279 | { |
| 7280 | if (IdenticalResourceRecord(&rr->resrec, &pktrr->resrec)) |
| 7281 | { |
| 7282 | while (rr->RRSet && rr != rr->RRSet) rr = rr->RRSet; |
| 7283 | return(rr); |
| 7284 | } |
| 7285 | } |
| 7286 | return(mDNSNULL); |
| 7287 | } |
| 7288 | |
| 7289 | // PacketRRConflict is called when we've received an RR (pktrr) which has the same name |
| 7290 | // as one of our records (our) but different rdata. |
| 7291 | // 1. If our record is not a type that's supposed to be unique, we don't care. |
| 7292 | // 2a. If our record is marked as dependent on some other record for conflict detection, ignore this one. |
| 7293 | // 2b. If the packet rr exactly matches one of our other RRs, and *that* record's DependentOn pointer |
| 7294 | // points to our record, ignore this conflict (e.g. the packet record matches one of our |
| 7295 | // TXT records, and that record is marked as dependent on 'our', its SRV record). |
| 7296 | // 3. If we have some *other* RR that exactly matches the one from the packet, and that record and our record |
| 7297 | // are members of the same RRSet, then this is not a conflict. |
| 7298 | mDNSlocal mDNSBool PacketRRConflict(const mDNS *const m, const AuthRecord *const our, const CacheRecord *const pktrr) |
| 7299 | { |
| 7300 | // If not supposed to be unique, not a conflict |
| 7301 | if (!(our->resrec.RecordType & kDNSRecordTypeUniqueMask)) return(mDNSfalse); |
| 7302 | |
| 7303 | // If a dependent record, not a conflict |
| 7304 | if (our->DependentOn || MatchDependentOn(m, pktrr, our)) return(mDNSfalse); |
| 7305 | else |
| 7306 | { |
| 7307 | // If the pktrr matches a member of ourset, not a conflict |
| 7308 | const AuthRecord *ourset = our->RRSet ? our->RRSet : our; |
| 7309 | const AuthRecord *pktset = FindRRSet(m, pktrr); |
| 7310 | if (pktset == ourset) return(mDNSfalse); |
| 7311 | |
| 7312 | // For records we're proxying, where we don't know the full |
| 7313 | // relationship between the records, having any matching record |
| 7314 | // in our AuthRecords list is sufficient evidence of non-conflict |
| 7315 | if (our->WakeUp.HMAC.l[0] && pktset) return(mDNSfalse); |
| 7316 | } |
| 7317 | |
| 7318 | // Okay, this is a conflict |
| 7319 | return(mDNStrue); |
| 7320 | } |
| 7321 | |
| 7322 | // Note: ResolveSimultaneousProbe calls mDNS_Deregister_internal which can call a user callback, which may change |
| 7323 | // the record list and/or question list. |
| 7324 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 7325 | mDNSlocal void ResolveSimultaneousProbe(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end, |
| 7326 | DNSQuestion *q, AuthRecord *our) |
| 7327 | { |
| 7328 | int i; |
| 7329 | const mDNSu8 *ptr = LocateAuthorities(query, end); |
| 7330 | mDNSBool FoundUpdate = mDNSfalse; |
| 7331 | |
| 7332 | for (i = 0; i < query->h.numAuthorities; i++) |
| 7333 | { |
| 7334 | ptr = GetLargeResourceRecord(m, query, ptr, end, q->InterfaceID, kDNSRecordTypePacketAuth, &m->rec); |
| 7335 | if (!ptr) break; |
| 7336 | if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && ResourceRecordAnswersQuestion(&m->rec.r.resrec, q)) |
| 7337 | { |
| 7338 | FoundUpdate = mDNStrue; |
| 7339 | if (PacketRRConflict(m, our, &m->rec.r)) |
| 7340 | { |
| 7341 | int result = (int)our->resrec.rrclass - (int)m->rec.r.resrec.rrclass; |
| 7342 | if (!result) result = (int)our->resrec.rrtype - (int)m->rec.r.resrec.rrtype; |
| 7343 | if (!result) result = CompareRData(our, &m->rec.r); |
| 7344 | if (result) |
| 7345 | { |
| 7346 | const char *const msg = (result < 0) ? "lost:" : (result > 0) ? "won: " : "tie: " ; |
| 7347 | LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s" , q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); |
| 7348 | LogMsg("ResolveSimultaneousProbe: %p Our Record %d %s %08lX %s" , our->resrec.InterfaceID, our->ProbeCount, msg, our->resrec.rdatahash, ARDisplayString(m, our)); |
| 7349 | } |
| 7350 | // If we lost the tie-break for simultaneous probes, we don't immediately give up, because we might be seeing stale packets on the network. |
| 7351 | // Instead we pause for one second, to give the other host (if real) a chance to establish its name, and then try probing again. |
| 7352 | // If there really is another live host out there with the same name, it will answer our probes and we'll then rename. |
| 7353 | if (result < 0) |
| 7354 | { |
| 7355 | m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond); |
| 7356 | our->ProbeCount = DefaultProbeCountForTypeUnique; |
| 7357 | our->AnnounceCount = InitialAnnounceCount; |
| 7358 | InitializeLastAPTime(m, our); |
| 7359 | goto exit; |
| 7360 | } |
| 7361 | } |
| 7362 | #if 0 |
| 7363 | else |
| 7364 | { |
| 7365 | LogMsg("ResolveSimultaneousProbe: %p Pkt Record: %08lX %s" , q->InterfaceID, m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); |
| 7366 | LogMsg("ResolveSimultaneousProbe: %p Our Record %d ign: %08lX %s" , our->resrec.InterfaceID, our->ProbeCount, our->resrec.rdatahash, ARDisplayString(m, our)); |
| 7367 | } |
| 7368 | #endif |
| 7369 | } |
| 7370 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 7371 | } |
| 7372 | if (!FoundUpdate) |
| 7373 | LogInfo("ResolveSimultaneousProbe: %##s (%s): No Update Record found" , our->resrec.name->c, DNSTypeName(our->resrec.rrtype)); |
| 7374 | exit: |
| 7375 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 7376 | } |
| 7377 | |
| 7378 | mDNSlocal CacheRecord *FindIdenticalRecordInCache(const mDNS *const m, const ResourceRecord *const pktrr) |
| 7379 | { |
| 7380 | CacheGroup *cg = CacheGroupForRecord(m, pktrr); |
| 7381 | CacheRecord *rr; |
| 7382 | mDNSBool match; |
| 7383 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 7384 | { |
| 7385 | if (!pktrr->InterfaceID) |
| 7386 | { |
| 7387 | mDNSu16 id1 = (pktrr->rDNSServer ? pktrr->rDNSServer->resGroupID : 0); |
| 7388 | mDNSu16 id2 = (rr->resrec.rDNSServer ? rr->resrec.rDNSServer->resGroupID : 0); |
| 7389 | match = (id1 == id2); |
| 7390 | } |
| 7391 | else match = (pktrr->InterfaceID == rr->resrec.InterfaceID); |
| 7392 | |
| 7393 | if (match && IdenticalSameNameRecord(pktrr, &rr->resrec)) break; |
| 7394 | } |
| 7395 | return(rr); |
| 7396 | } |
| 7397 | mDNSlocal void DeregisterProxyRecord(mDNS *const m, AuthRecord *const rr) |
| 7398 | { |
| 7399 | rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host |
| 7400 | rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it |
| 7401 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); |
| 7402 | SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID); |
| 7403 | } |
| 7404 | |
| 7405 | mDNSlocal void ClearKeepaliveProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist, const mDNSInterfaceID InterfaceID) |
| 7406 | { |
| 7407 | if (m->CurrentRecord) |
| 7408 | LogMsg("ClearKeepaliveProxyRecords ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 7409 | m->CurrentRecord = thelist; |
| 7410 | |
| 7411 | // Normally, the RDATA of the keepalive record will be different each time and hence we always |
| 7412 | // clean up the keepalive record. |
| 7413 | while (m->CurrentRecord) |
| 7414 | { |
| 7415 | AuthRecord *const rr = m->CurrentRecord; |
| 7416 | if (InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) |
| 7417 | { |
| 7418 | if (mDNS_KeepaliveRecord(&m->rec.r.resrec)) |
| 7419 | { |
| 7420 | LogSPS("ClearKeepaliveProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s" , |
| 7421 | m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); |
| 7422 | DeregisterProxyRecord(m, rr); |
| 7423 | } |
| 7424 | } |
| 7425 | // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because |
| 7426 | // new records could have been added to the end of the list as a result of that call. |
| 7427 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 7428 | m->CurrentRecord = rr->next; |
| 7429 | } |
| 7430 | } |
| 7431 | |
| 7432 | // Called from mDNSCoreReceiveUpdate when we get a sleep proxy registration request, |
| 7433 | // to check our lists and discard any stale duplicates of this record we already have |
| 7434 | mDNSlocal void ClearIdenticalProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist) |
| 7435 | { |
| 7436 | if (m->CurrentRecord) |
| 7437 | LogMsg("ClearIdenticalProxyRecords ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 7438 | m->CurrentRecord = thelist; |
| 7439 | while (m->CurrentRecord) |
| 7440 | { |
| 7441 | AuthRecord *const rr = m->CurrentRecord; |
| 7442 | if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) |
| 7443 | if (IdenticalResourceRecord(&rr->resrec, &m->rec.r.resrec)) |
| 7444 | { |
| 7445 | LogSPS("ClearIdenticalProxyRecords: Removing %3d H-MAC %.6a I-MAC %.6a %d %d %s" , |
| 7446 | m->ProxyRecords, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); |
| 7447 | DeregisterProxyRecord(m, rr); |
| 7448 | } |
| 7449 | // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because |
| 7450 | // new records could have been added to the end of the list as a result of that call. |
| 7451 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 7452 | m->CurrentRecord = rr->next; |
| 7453 | } |
| 7454 | } |
| 7455 | |
| 7456 | // Called from ProcessQuery when we get an mDNS packet with an owner record in it |
| 7457 | mDNSlocal void ClearProxyRecords(mDNS *const m, const OwnerOptData *const owner, AuthRecord *const thelist) |
| 7458 | { |
| 7459 | if (m->CurrentRecord) |
| 7460 | LogMsg("ClearProxyRecords ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 7461 | m->CurrentRecord = thelist; |
| 7462 | while (m->CurrentRecord) |
| 7463 | { |
| 7464 | AuthRecord *const rr = m->CurrentRecord; |
| 7465 | if (m->rec.r.resrec.InterfaceID == rr->resrec.InterfaceID && mDNSSameEthAddress(&owner->HMAC, &rr->WakeUp.HMAC)) |
| 7466 | if (owner->seq != rr->WakeUp.seq || m->timenow - rr->TimeRcvd > mDNSPlatformOneSecond * 60) |
| 7467 | { |
| 7468 | if (rr->AddressProxy.type == mDNSAddrType_IPv6) |
| 7469 | { |
| 7470 | // We don't do this here because we know that the host is waking up at this point, so we don't send |
| 7471 | // Unsolicited Neighbor Advertisements -- even Neighbor Advertisements agreeing with what the host should be |
| 7472 | // saying itself -- because it can cause some IPv6 stacks to falsely conclude that there's an address conflict. |
| 7473 | #if MDNS_USE_Unsolicited_Neighbor_Advertisements |
| 7474 | LogSPS("NDP Announcement -- Releasing traffic for H-MAC %.6a I-MAC %.6a %s" , |
| 7475 | &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m,rr)); |
| 7476 | SendNDP(m, NDP_Adv, NDP_Override, rr, &rr->AddressProxy.ip.v6, &rr->WakeUp.IMAC, &AllHosts_v6, &AllHosts_v6_Eth); |
| 7477 | #endif |
| 7478 | } |
| 7479 | LogSPS("ClearProxyRecords: Removing %3d AC %2d %02X H-MAC %.6a I-MAC %.6a %d %d %s" , |
| 7480 | m->ProxyRecords, rr->AnnounceCount, rr->resrec.RecordType, |
| 7481 | &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, rr->WakeUp.seq, owner->seq, ARDisplayString(m, rr)); |
| 7482 | if (rr->resrec.RecordType == kDNSRecordTypeDeregistering) rr->resrec.RecordType = kDNSRecordTypeShared; |
| 7483 | rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host |
| 7484 | rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it, since real host is now back and functional |
| 7485 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); |
| 7486 | SetSPSProxyListChanged(m->rec.r.resrec.InterfaceID); |
| 7487 | } |
| 7488 | // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because |
| 7489 | // new records could have been added to the end of the list as a result of that call. |
| 7490 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 7491 | m->CurrentRecord = rr->next; |
| 7492 | } |
| 7493 | } |
| 7494 | |
| 7495 | // ProcessQuery examines a received query to see if we have any answers to give |
| 7496 | mDNSlocal mDNSu8 *ProcessQuery(mDNS *const m, const DNSMessage *const query, const mDNSu8 *const end, |
| 7497 | const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID, mDNSBool LegacyQuery, mDNSBool QueryWasMulticast, |
| 7498 | mDNSBool QueryWasLocalUnicast, DNSMessage *const response) |
| 7499 | { |
| 7500 | mDNSBool FromLocalSubnet = srcaddr && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); |
| 7501 | AuthRecord *ResponseRecords = mDNSNULL; |
| 7502 | AuthRecord **nrp = &ResponseRecords; |
| 7503 | |
| 7504 | #if POOF_ENABLED |
| 7505 | CacheRecord *ExpectedAnswers = mDNSNULL; // Records in our cache we expect to see updated |
| 7506 | CacheRecord **eap = &ExpectedAnswers; |
| 7507 | #endif // POOF_ENABLED |
| 7508 | |
| 7509 | DNSQuestion *DupQuestions = mDNSNULL; // Our questions that are identical to questions in this packet |
| 7510 | DNSQuestion **dqp = &DupQuestions; |
| 7511 | mDNSs32 delayresponse = 0; |
| 7512 | mDNSBool SendLegacyResponse = mDNSfalse; |
| 7513 | const mDNSu8 *ptr; |
| 7514 | mDNSu8 *responseptr = mDNSNULL; |
| 7515 | AuthRecord *rr; |
| 7516 | int i; |
| 7517 | CacheRecord *McastNSEC3Records = mDNSNULL; |
| 7518 | |
| 7519 | // *** |
| 7520 | // *** 1. Look in Additional Section for an OPT record |
| 7521 | // *** |
| 7522 | ptr = LocateOptRR(query, end, DNSOpt_OwnerData_ID_Space); |
| 7523 | if (ptr) |
| 7524 | { |
| 7525 | ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAdd, &m->rec); |
| 7526 | if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) |
| 7527 | { |
| 7528 | const rdataOPT *opt; |
| 7529 | const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; |
| 7530 | // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently |
| 7531 | // delete all our own AuthRecords (which are identified by having zero MAC tags on them). |
| 7532 | for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++) |
| 7533 | if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0]) |
| 7534 | { |
| 7535 | ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords); |
| 7536 | ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords); |
| 7537 | } |
| 7538 | } |
| 7539 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 7540 | } |
| 7541 | |
| 7542 | // |
| 7543 | // Look in Authority Section for NSEC3 record |
| 7544 | // |
| 7545 | |
| 7546 | mDNSParseNSEC3Records(m, query, end, InterfaceID, &McastNSEC3Records); |
| 7547 | |
| 7548 | // *** |
| 7549 | // *** 2. Parse Question Section and mark potential answers |
| 7550 | // *** |
| 7551 | ptr = query->data; |
| 7552 | for (i=0; i<query->h.numQuestions; i++) // For each question... |
| 7553 | { |
| 7554 | mDNSBool QuestionNeedsMulticastResponse; |
| 7555 | int NumAnswersForThisQuestion = 0; |
| 7556 | AuthRecord *NSECAnswer = mDNSNULL; |
| 7557 | DNSQuestion pktq, *q; |
| 7558 | ptr = getQuestion(query, ptr, end, InterfaceID, &pktq); // get the question... |
| 7559 | if (!ptr) goto exit; |
| 7560 | |
| 7561 | pktq.AnonInfo = mDNSNULL; |
| 7562 | if (McastNSEC3Records) |
| 7563 | InitializeAnonInfoForQuestion(m, &McastNSEC3Records, &pktq); |
| 7564 | // The only queries that *need* a multicast response are: |
| 7565 | // * Queries sent via multicast |
| 7566 | // * from port 5353 |
| 7567 | // * that don't have the kDNSQClass_UnicastResponse bit set |
| 7568 | // These queries need multicast responses because other clients will: |
| 7569 | // * suppress their own identical questions when they see these questions, and |
| 7570 | // * expire their cache records if they don't see the expected responses |
| 7571 | // For other queries, we may still choose to send the occasional multicast response anyway, |
| 7572 | // to keep our neighbours caches warm, and for ongoing conflict detection. |
| 7573 | QuestionNeedsMulticastResponse = QueryWasMulticast && !LegacyQuery && !(pktq.qclass & kDNSQClass_UnicastResponse); |
| 7574 | |
| 7575 | if (pktq.qclass & kDNSQClass_UnicastResponse) |
| 7576 | m->mDNSStats.UnicastBitInQueries++; |
| 7577 | else |
| 7578 | m->mDNSStats.NormalQueries++; |
| 7579 | |
| 7580 | // Clear the UnicastResponse flag -- don't want to confuse the rest of the code that follows later |
| 7581 | pktq.qclass &= ~kDNSQClass_UnicastResponse; |
| 7582 | |
| 7583 | // Note: We use the m->CurrentRecord mechanism here because calling ResolveSimultaneousProbe |
| 7584 | // can result in user callbacks which may change the record list and/or question list. |
| 7585 | // Also note: we just mark potential answer records here, without trying to build the |
| 7586 | // "ResponseRecords" list, because we don't want to risk user callbacks deleting records |
| 7587 | // from that list while we're in the middle of trying to build it. |
| 7588 | if (m->CurrentRecord) |
| 7589 | LogMsg("ProcessQuery ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 7590 | m->CurrentRecord = m->ResourceRecords; |
| 7591 | while (m->CurrentRecord) |
| 7592 | { |
| 7593 | rr = m->CurrentRecord; |
| 7594 | m->CurrentRecord = rr->next; |
| 7595 | if (AnyTypeRecordAnswersQuestion(&rr->resrec, &pktq) && (QueryWasMulticast || QueryWasLocalUnicast || rr->AllowRemoteQuery)) |
| 7596 | { |
| 7597 | m->mDNSStats.MatchingAnswersForQueries++; |
| 7598 | if (RRTypeAnswersQuestionType(&rr->resrec, pktq.qtype)) |
| 7599 | { |
| 7600 | if (rr->resrec.RecordType == kDNSRecordTypeUnique) |
| 7601 | ResolveSimultaneousProbe(m, query, end, &pktq, rr); |
| 7602 | else if (ResourceRecordIsValidAnswer(rr)) |
| 7603 | { |
| 7604 | NumAnswersForThisQuestion++; |
| 7605 | // As we have verified this question to be part of the same subset, |
| 7606 | // set the anonymous data which is needed below when walk the cache |
| 7607 | // records to see what answers we should be expecting. The cache records |
| 7608 | // may cache only the nsec3RR and not the anonymous data itself. |
| 7609 | if (pktq.AnonInfo && rr->resrec.AnonInfo) |
| 7610 | SetAnonData(&pktq, &rr->resrec, mDNStrue); |
| 7611 | |
| 7612 | // Note: We should check here if this is a probe-type query, and if so, generate an immediate |
| 7613 | // unicast answer back to the source, because timeliness in answering probes is important. |
| 7614 | |
| 7615 | // Notes: |
| 7616 | // NR_AnswerTo pointing into query packet means "answer via immediate legacy unicast" (may *also* choose to multicast) |
| 7617 | // NR_AnswerTo == NR_AnswerUnicast means "answer via delayed unicast" (to modern querier; may promote to multicast instead) |
| 7618 | // NR_AnswerTo == NR_AnswerMulticast means "definitely answer via multicast" (can't downgrade to unicast later) |
| 7619 | // If we're not multicasting this record because the kDNSQClass_UnicastResponse bit was set, |
| 7620 | // but the multicast querier is not on a matching subnet (e.g. because of overlaid subnets on one link) |
| 7621 | // then we'll multicast it anyway (if we unicast, the receiver will ignore it because it has an apparently non-local source) |
| 7622 | if (QuestionNeedsMulticastResponse || (!FromLocalSubnet && QueryWasMulticast && !LegacyQuery)) |
| 7623 | { |
| 7624 | // We only mark this question for sending if it is at least one second since the last time we multicast it |
| 7625 | // on this interface. If it is more than a second, or LastMCInterface is different, then we may multicast it. |
| 7626 | // This is to guard against the case where someone blasts us with queries as fast as they can. |
| 7627 | if ((mDNSu32)(m->timenow - rr->LastMCTime) >= (mDNSu32)mDNSPlatformOneSecond || |
| 7628 | (rr->LastMCInterface != mDNSInterfaceMark && rr->LastMCInterface != InterfaceID)) |
| 7629 | rr->NR_AnswerTo = NR_AnswerMulticast; |
| 7630 | } |
| 7631 | else if (!rr->NR_AnswerTo) rr->NR_AnswerTo = LegacyQuery ? ptr : NR_AnswerUnicast; |
| 7632 | } |
| 7633 | } |
| 7634 | else if ((rr->resrec.RecordType & kDNSRecordTypeActiveUniqueMask) && ResourceRecordIsValidAnswer(rr)) |
| 7635 | { |
| 7636 | // If we don't have any answers for this question, but we do own another record with the same name, |
| 7637 | // then we'll want to mark it to generate an NSEC record on this interface |
| 7638 | if (!NSECAnswer) NSECAnswer = rr; |
| 7639 | } |
| 7640 | } |
| 7641 | } |
| 7642 | |
| 7643 | if (NumAnswersForThisQuestion == 0 && NSECAnswer) |
| 7644 | { |
| 7645 | NumAnswersForThisQuestion++; |
| 7646 | NSECAnswer->SendNSECNow = InterfaceID; |
| 7647 | m->NextScheduledResponse = m->timenow; |
| 7648 | } |
| 7649 | |
| 7650 | // If we couldn't answer this question, someone else might be able to, |
| 7651 | // so use random delay on response to reduce collisions |
| 7652 | if (NumAnswersForThisQuestion == 0) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms |
| 7653 | |
| 7654 | if (query->h.flags.b[0] & kDNSFlag0_TC) |
| 7655 | m->mDNSStats.KnownAnswerMultiplePkts++; |
| 7656 | // We only do the following accelerated cache expiration and duplicate question suppression processing |
| 7657 | // for non-truncated multicast queries with multicast responses. |
| 7658 | // For any query generating a unicast response we don't do this because we can't assume we will see the response. |
| 7659 | // For truncated queries we don't do this because a response we're expecting might be suppressed by a subsequent |
| 7660 | // known-answer packet, and when there's packet loss we can't safely assume we'll receive *all* known-answer packets. |
| 7661 | if (QuestionNeedsMulticastResponse && !(query->h.flags.b[0] & kDNSFlag0_TC)) |
| 7662 | { |
| 7663 | #if POOF_ENABLED |
| 7664 | CacheGroup *cg = CacheGroupForName(m, pktq.qnamehash, &pktq.qname); |
| 7665 | CacheRecord *cr; |
| 7666 | |
| 7667 | // Make a list indicating which of our own cache records we expect to see updated as a result of this query |
| 7668 | // Note: Records larger than 1K are not habitually multicast, so don't expect those to be updated |
| 7669 | for (cr = cg ? cg->members : mDNSNULL; cr; cr=cr->next) |
| 7670 | if (SameNameRecordAnswersQuestion(&cr->resrec, &pktq) && cr->resrec.rdlength <= SmallRecordLimit) |
| 7671 | if (!cr->NextInKAList && eap != &cr->NextInKAList) |
| 7672 | { |
| 7673 | *eap = cr; |
| 7674 | eap = &cr->NextInKAList; |
| 7675 | } |
| 7676 | #endif // POOF_ENABLED |
| 7677 | |
| 7678 | // Check if this question is the same as any of mine. |
| 7679 | // We only do this for non-truncated queries. Right now it would be too complicated to try |
| 7680 | // to keep track of duplicate suppression state between multiple packets, especially when we |
| 7681 | // can't guarantee to receive all of the Known Answer packets that go with a particular query. |
| 7682 | // For anonymous question, the duplicate suppressesion should happen if the |
| 7683 | // question belongs in the same group. As the group is expected to be |
| 7684 | // small, we don't do the optimization for now. |
| 7685 | if (!pktq.AnonInfo) |
| 7686 | { |
| 7687 | for (q = m->Questions; q; q=q->next) |
| 7688 | if (!q->Target.type && ActiveQuestion(q) && m->timenow - q->LastQTxTime > mDNSPlatformOneSecond / 4) |
| 7689 | if (!q->InterfaceID || q->InterfaceID == InterfaceID) |
| 7690 | if (q->NextInDQList == mDNSNULL && dqp != &q->NextInDQList) |
| 7691 | if (q->qtype == pktq.qtype && |
| 7692 | q->qclass == pktq.qclass && |
| 7693 | q->qnamehash == pktq.qnamehash && SameDomainName(&q->qname, &pktq.qname)) |
| 7694 | { *dqp = q; dqp = &q->NextInDQList; } |
| 7695 | } |
| 7696 | } |
| 7697 | if (pktq.AnonInfo) |
| 7698 | { |
| 7699 | FreeAnonInfo(pktq.AnonInfo); |
| 7700 | } |
| 7701 | } |
| 7702 | |
| 7703 | // *** |
| 7704 | // *** 3. Now we can safely build the list of marked answers |
| 7705 | // *** |
| 7706 | for (rr = m->ResourceRecords; rr; rr=rr->next) // Now build our list of potential answers |
| 7707 | if (rr->NR_AnswerTo) // If we marked the record... |
| 7708 | AddRecordToResponseList(&nrp, rr, mDNSNULL); // ... add it to the list |
| 7709 | |
| 7710 | // *** |
| 7711 | // *** 4. Add additional records |
| 7712 | // *** |
| 7713 | AddAdditionalsToResponseList(m, ResponseRecords, &nrp, InterfaceID); |
| 7714 | |
| 7715 | // *** |
| 7716 | // *** 5. Parse Answer Section and cancel any records disallowed by Known-Answer list |
| 7717 | // *** |
| 7718 | for (i=0; i<query->h.numAnswers; i++) // For each record in the query's answer section... |
| 7719 | { |
| 7720 | // Get the record... |
| 7721 | CacheRecord *ourcacherr; |
| 7722 | ptr = GetLargeResourceRecord(m, query, ptr, end, InterfaceID, kDNSRecordTypePacketAns, &m->rec); |
| 7723 | if (!ptr) goto exit; |
| 7724 | if (m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) |
| 7725 | { |
| 7726 | // See if this Known-Answer suppresses any of our currently planned answers |
| 7727 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) |
| 7728 | { |
| 7729 | if (MustSendRecord(rr) && ShouldSuppressKnownAnswer(&m->rec.r, rr)) |
| 7730 | { |
| 7731 | m->mDNSStats.KnownAnswerSuppressions++; |
| 7732 | rr->NR_AnswerTo = mDNSNULL; |
| 7733 | rr->NR_AdditionalTo = mDNSNULL; |
| 7734 | } |
| 7735 | } |
| 7736 | |
| 7737 | // See if this Known-Answer suppresses any previously scheduled answers (for multi-packet KA suppression) |
| 7738 | for (rr=m->ResourceRecords; rr; rr=rr->next) |
| 7739 | { |
| 7740 | // If we're planning to send this answer on this interface, and only on this interface, then allow KA suppression |
| 7741 | if (rr->ImmedAnswer == InterfaceID && ShouldSuppressKnownAnswer(&m->rec.r, rr)) |
| 7742 | { |
| 7743 | if (srcaddr->type == mDNSAddrType_IPv4) |
| 7744 | { |
| 7745 | if (mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = zerov4Addr; |
| 7746 | } |
| 7747 | else if (srcaddr->type == mDNSAddrType_IPv6) |
| 7748 | { |
| 7749 | if (mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = zerov6Addr; |
| 7750 | } |
| 7751 | if (mDNSIPv4AddressIsZero(rr->v4Requester) && mDNSIPv6AddressIsZero(rr->v6Requester)) |
| 7752 | { |
| 7753 | m->mDNSStats.KnownAnswerSuppressions++; |
| 7754 | rr->ImmedAnswer = mDNSNULL; |
| 7755 | rr->ImmedUnicast = mDNSfalse; |
| 7756 | #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES |
| 7757 | LogMsg("Suppressed after%4d: %s" , m->timenow - rr->ImmedAnswerMarkTime, ARDisplayString(m, rr)); |
| 7758 | #endif |
| 7759 | } |
| 7760 | } |
| 7761 | } |
| 7762 | |
| 7763 | ourcacherr = FindIdenticalRecordInCache(m, &m->rec.r.resrec); |
| 7764 | |
| 7765 | #if POOF_ENABLED |
| 7766 | // Having built our ExpectedAnswers list from the questions in this packet, we then remove |
| 7767 | // any records that are suppressed by the Known Answer list in this packet. |
| 7768 | eap = &ExpectedAnswers; |
| 7769 | while (*eap) |
| 7770 | { |
| 7771 | CacheRecord *cr = *eap; |
| 7772 | if (cr->resrec.InterfaceID == InterfaceID && IdenticalResourceRecord(&m->rec.r.resrec, &cr->resrec)) |
| 7773 | { *eap = cr->NextInKAList; cr->NextInKAList = mDNSNULL; } |
| 7774 | else eap = &cr->NextInKAList; |
| 7775 | } |
| 7776 | #endif // POOF_ENABLED |
| 7777 | |
| 7778 | // See if this Known-Answer is a surprise to us. If so, we shouldn't suppress our own query. |
| 7779 | if (!ourcacherr) |
| 7780 | { |
| 7781 | dqp = &DupQuestions; |
| 7782 | while (*dqp) |
| 7783 | { |
| 7784 | DNSQuestion *q = *dqp; |
| 7785 | if (ResourceRecordAnswersQuestion(&m->rec.r.resrec, q)) |
| 7786 | { *dqp = q->NextInDQList; q->NextInDQList = mDNSNULL; } |
| 7787 | else dqp = &q->NextInDQList; |
| 7788 | } |
| 7789 | } |
| 7790 | } |
| 7791 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 7792 | } |
| 7793 | |
| 7794 | // *** |
| 7795 | // *** 6. Cancel any additionals that were added because of now-deleted records |
| 7796 | // *** |
| 7797 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) |
| 7798 | if (rr->NR_AdditionalTo && !MustSendRecord(rr->NR_AdditionalTo)) |
| 7799 | { rr->NR_AnswerTo = mDNSNULL; rr->NR_AdditionalTo = mDNSNULL; } |
| 7800 | |
| 7801 | // *** |
| 7802 | // *** 7. Mark the send flags on the records we plan to send |
| 7803 | // *** |
| 7804 | for (rr=ResponseRecords; rr; rr=rr->NextResponse) |
| 7805 | { |
| 7806 | if (rr->NR_AnswerTo) |
| 7807 | { |
| 7808 | mDNSBool SendMulticastResponse = mDNSfalse; // Send modern multicast response |
| 7809 | mDNSBool SendUnicastResponse = mDNSfalse; // Send modern unicast response (not legacy unicast response) |
| 7810 | |
| 7811 | // If it's been one TTL/4 since we multicast this, then send a multicast response |
| 7812 | // for conflict detection, etc. |
| 7813 | if ((mDNSu32)(m->timenow - rr->LastMCTime) >= (mDNSu32)TicksTTL(rr)/4) |
| 7814 | { |
| 7815 | SendMulticastResponse = mDNStrue; |
| 7816 | // If this record was marked for modern (delayed) unicast response, then mark it as promoted to |
| 7817 | // multicast response instead (don't want to end up ALSO setting SendUnicastResponse in the check below). |
| 7818 | // If this record was marked for legacy unicast response, then we mustn't change the NR_AnswerTo value. |
| 7819 | if (rr->NR_AnswerTo == NR_AnswerUnicast) |
| 7820 | { |
| 7821 | m->mDNSStats.UnicastDemotedToMulticast++; |
| 7822 | rr->NR_AnswerTo = NR_AnswerMulticast; |
| 7823 | } |
| 7824 | } |
| 7825 | |
| 7826 | // If the client insists on a multicast response, then we'd better send one |
| 7827 | if (rr->NR_AnswerTo == NR_AnswerMulticast) |
| 7828 | { |
| 7829 | m->mDNSStats.MulticastResponses++; |
| 7830 | SendMulticastResponse = mDNStrue; |
| 7831 | } |
| 7832 | else if (rr->NR_AnswerTo == NR_AnswerUnicast) |
| 7833 | { |
| 7834 | m->mDNSStats.UnicastResponses++; |
| 7835 | SendUnicastResponse = mDNStrue; |
| 7836 | } |
| 7837 | else if (rr->NR_AnswerTo) |
| 7838 | { |
| 7839 | SendLegacyResponse = mDNStrue; |
| 7840 | } |
| 7841 | |
| 7842 | if (SendMulticastResponse || SendUnicastResponse) |
| 7843 | { |
| 7844 | #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES |
| 7845 | rr->ImmedAnswerMarkTime = m->timenow; |
| 7846 | #endif |
| 7847 | m->NextScheduledResponse = m->timenow; |
| 7848 | // If we're already planning to send this on another interface, just send it on all interfaces |
| 7849 | if (rr->ImmedAnswer && rr->ImmedAnswer != InterfaceID) |
| 7850 | rr->ImmedAnswer = mDNSInterfaceMark; |
| 7851 | else |
| 7852 | { |
| 7853 | rr->ImmedAnswer = InterfaceID; // Record interface to send it on |
| 7854 | if (SendUnicastResponse) rr->ImmedUnicast = mDNStrue; |
| 7855 | if (srcaddr->type == mDNSAddrType_IPv4) |
| 7856 | { |
| 7857 | if (mDNSIPv4AddressIsZero(rr->v4Requester)) rr->v4Requester = srcaddr->ip.v4; |
| 7858 | else if (!mDNSSameIPv4Address(rr->v4Requester, srcaddr->ip.v4)) rr->v4Requester = onesIPv4Addr; |
| 7859 | } |
| 7860 | else if (srcaddr->type == mDNSAddrType_IPv6) |
| 7861 | { |
| 7862 | if (mDNSIPv6AddressIsZero(rr->v6Requester)) rr->v6Requester = srcaddr->ip.v6; |
| 7863 | else if (!mDNSSameIPv6Address(rr->v6Requester, srcaddr->ip.v6)) rr->v6Requester = onesIPv6Addr; |
| 7864 | } |
| 7865 | } |
| 7866 | } |
| 7867 | // If TC flag is set, it means we should expect that additional known answers may be coming in another packet, |
| 7868 | // so we allow roughly half a second before deciding to reply (we've observed inter-packet delays of 100-200ms on 802.11) |
| 7869 | // else, if record is a shared one, spread responses over 100ms to avoid implosion of simultaneous responses |
| 7870 | // else, for a simple unique record reply, we can reply immediately; no need for delay |
| 7871 | if (query->h.flags.b[0] & kDNSFlag0_TC) delayresponse = mDNSPlatformOneSecond * 20; // Divided by 50 = 400ms |
| 7872 | else if (rr->resrec.RecordType == kDNSRecordTypeShared) delayresponse = mDNSPlatformOneSecond; // Divided by 50 = 20ms |
| 7873 | } |
| 7874 | else if (rr->NR_AdditionalTo && rr->NR_AdditionalTo->NR_AnswerTo == NR_AnswerMulticast) |
| 7875 | { |
| 7876 | // Since additional records are an optimization anyway, we only ever send them on one interface at a time |
| 7877 | // If two clients on different interfaces do queries that invoke the same optional additional answer, |
| 7878 | // then the earlier client is out of luck |
| 7879 | rr->ImmedAdditional = InterfaceID; |
| 7880 | // No need to set m->NextScheduledResponse here |
| 7881 | // We'll send these additional records when we send them, or not, as the case may be |
| 7882 | } |
| 7883 | } |
| 7884 | |
| 7885 | // *** |
| 7886 | // *** 8. If we think other machines are likely to answer these questions, set our packet suppression timer |
| 7887 | // *** |
| 7888 | if (delayresponse && (!m->SuppressSending || (m->SuppressSending - m->timenow) < (delayresponse + 49) / 50)) |
| 7889 | { |
| 7890 | #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES |
| 7891 | mDNSs32 oldss = m->SuppressSending; |
| 7892 | if (oldss && delayresponse) |
| 7893 | LogMsg("Current SuppressSending delay%5ld; require%5ld" , m->SuppressSending - m->timenow, (delayresponse + 49) / 50); |
| 7894 | #endif |
| 7895 | // Pick a random delay: |
| 7896 | // We start with the base delay chosen above (typically either 1 second or 20 seconds), |
| 7897 | // and add a random value in the range 0-5 seconds (making 1-6 seconds or 20-25 seconds). |
| 7898 | // This is an integer value, with resolution determined by the platform clock rate. |
| 7899 | // We then divide that by 50 to get the delay value in ticks. We defer the division until last |
| 7900 | // to get better results on platforms with coarse clock granularity (e.g. ten ticks per second). |
| 7901 | // The +49 before dividing is to ensure we round up, not down, to ensure that even |
| 7902 | // on platforms where the native clock rate is less than fifty ticks per second, |
| 7903 | // we still guarantee that the final calculated delay is at least one platform tick. |
| 7904 | // We want to make sure we don't ever allow the delay to be zero ticks, |
| 7905 | // because if that happens we'll fail the Bonjour Conformance Test. |
| 7906 | // Our final computed delay is 20-120ms for normal delayed replies, |
| 7907 | // or 400-500ms in the case of multi-packet known-answer lists. |
| 7908 | m->SuppressSending = m->timenow + (delayresponse + (mDNSs32)mDNSRandom((mDNSu32)mDNSPlatformOneSecond*5) + 49) / 50; |
| 7909 | if (m->SuppressSending == 0) m->SuppressSending = 1; |
| 7910 | #if MDNS_LOG_ANSWER_SUPPRESSION_TIMES |
| 7911 | if (oldss && delayresponse) |
| 7912 | LogMsg("Set SuppressSending to %5ld" , m->SuppressSending - m->timenow); |
| 7913 | #endif |
| 7914 | } |
| 7915 | |
| 7916 | // *** |
| 7917 | // *** 9. If query is from a legacy client, or from a new client requesting a unicast reply, then generate a unicast response too |
| 7918 | // *** |
| 7919 | if (SendLegacyResponse) |
| 7920 | responseptr = GenerateUnicastResponse(query, end, InterfaceID, LegacyQuery, response, ResponseRecords); |
| 7921 | |
| 7922 | exit: |
| 7923 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 7924 | |
| 7925 | // *** |
| 7926 | // *** 10. Finally, clear our link chains ready for use next time |
| 7927 | // *** |
| 7928 | while (ResponseRecords) |
| 7929 | { |
| 7930 | rr = ResponseRecords; |
| 7931 | ResponseRecords = rr->NextResponse; |
| 7932 | rr->NextResponse = mDNSNULL; |
| 7933 | rr->NR_AnswerTo = mDNSNULL; |
| 7934 | rr->NR_AdditionalTo = mDNSNULL; |
| 7935 | } |
| 7936 | |
| 7937 | #if POOF_ENABLED |
| 7938 | while (ExpectedAnswers) |
| 7939 | { |
| 7940 | CacheRecord *cr = ExpectedAnswers; |
| 7941 | ExpectedAnswers = cr->NextInKAList; |
| 7942 | cr->NextInKAList = mDNSNULL; |
| 7943 | |
| 7944 | // For non-truncated queries, we can definitively say that we should expect |
| 7945 | // to be seeing a response for any records still left in the ExpectedAnswers list |
| 7946 | if (!(query->h.flags.b[0] & kDNSFlag0_TC)) |
| 7947 | if (cr->UnansweredQueries == 0 || m->timenow - cr->LastUnansweredTime >= mDNSPlatformOneSecond * 3/4) |
| 7948 | { |
| 7949 | cr->UnansweredQueries++; |
| 7950 | cr->LastUnansweredTime = m->timenow; |
| 7951 | if (cr->UnansweredQueries > 1) |
| 7952 | debugf("ProcessQuery: UnansweredQueries %lu %s" , cr->UnansweredQueries, CRDisplayString(m, cr)); |
| 7953 | SetNextCacheCheckTimeForRecord(m, cr); |
| 7954 | } |
| 7955 | |
| 7956 | // If we've seen multiple unanswered queries for this record, |
| 7957 | // then mark it to expire in five seconds if we don't get a response by then. |
| 7958 | if (cr->UnansweredQueries >= MaxUnansweredQueries) |
| 7959 | { |
| 7960 | // Only show debugging message if this record was not about to expire anyway |
| 7961 | if (RRExpireTime(cr) - m->timenow > (mDNSs32) kDefaultReconfirmTimeForNoAnswer * 4 / 3 + mDNSPlatformOneSecond) |
| 7962 | LogInfo("ProcessQuery: UnansweredQueries %lu interface %lu TTL %lu mDNS_Reconfirm() for %s" , |
| 7963 | cr->UnansweredQueries, InterfaceID, (RRExpireTime(cr) - m->timenow + mDNSPlatformOneSecond-1) / mDNSPlatformOneSecond, CRDisplayString(m, cr)); |
| 7964 | |
| 7965 | m->mDNSStats.PoofCacheDeletions++; |
| 7966 | mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); |
| 7967 | } |
| 7968 | } |
| 7969 | #endif // POOF_ENABLED |
| 7970 | |
| 7971 | while (DupQuestions) |
| 7972 | { |
| 7973 | DNSQuestion *q = DupQuestions; |
| 7974 | DupQuestions = q->NextInDQList; |
| 7975 | q->NextInDQList = mDNSNULL; |
| 7976 | RecordDupSuppressInfo(q->DupSuppress, m->timenow, InterfaceID, srcaddr->type); |
| 7977 | debugf("ProcessQuery: Recorded DSI for %##s (%s) on %p/%s" , q->qname.c, DNSTypeName(q->qtype), InterfaceID, |
| 7978 | srcaddr->type == mDNSAddrType_IPv4 ? "v4" : "v6" ); |
| 7979 | } |
| 7980 | |
| 7981 | if (McastNSEC3Records) |
| 7982 | { |
| 7983 | debugf("ProcessQuery: McastNSEC3Records not used" ); |
| 7984 | FreeNSECRecords(m, McastNSEC3Records); |
| 7985 | } |
| 7986 | |
| 7987 | return(responseptr); |
| 7988 | } |
| 7989 | |
| 7990 | mDNSlocal void mDNSCoreReceiveQuery(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *const end, |
| 7991 | const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, |
| 7992 | const mDNSInterfaceID InterfaceID) |
| 7993 | { |
| 7994 | mDNSu8 *responseend = mDNSNULL; |
| 7995 | mDNSBool QueryWasLocalUnicast = srcaddr && dstaddr && |
| 7996 | !mDNSAddrIsDNSMulticast(dstaddr) && mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); |
| 7997 | |
| 7998 | if (!dstaddr || (!InterfaceID && mDNSAddrIsDNSMulticast(dstaddr))) |
| 7999 | { |
| 8000 | const char *const reason = !dstaddr ? "Received over TCP connection" : "Multicast, but no InterfaceID" ; |
| 8001 | LogMsg("Ignoring Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " |
| 8002 | "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes (%s)" , |
| 8003 | srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, |
| 8004 | msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s," , |
| 8005 | msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s," , |
| 8006 | msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies," , |
| 8007 | msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s" , end - msg->data, reason); |
| 8008 | return; |
| 8009 | } |
| 8010 | |
| 8011 | verbosedebugf("Received Query from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " |
| 8012 | "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes" , |
| 8013 | srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, |
| 8014 | msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s," , |
| 8015 | msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s," , |
| 8016 | msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies," , |
| 8017 | msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s" , end - msg->data); |
| 8018 | |
| 8019 | responseend = ProcessQuery(m, msg, end, srcaddr, InterfaceID, |
| 8020 | !mDNSSameIPPort(srcport, MulticastDNSPort), mDNSAddrIsDNSMulticast(dstaddr), QueryWasLocalUnicast, &m->omsg); |
| 8021 | |
| 8022 | if (responseend) // If responseend is non-null, that means we built a unicast response packet |
| 8023 | { |
| 8024 | debugf("Unicast Response: %d Question%s, %d Answer%s, %d Additional%s to %#-15a:%d on %p/%ld" , |
| 8025 | m->omsg.h.numQuestions, m->omsg.h.numQuestions == 1 ? "" : "s" , |
| 8026 | m->omsg.h.numAnswers, m->omsg.h.numAnswers == 1 ? "" : "s" , |
| 8027 | m->omsg.h.numAdditionals, m->omsg.h.numAdditionals == 1 ? "" : "s" , |
| 8028 | srcaddr, mDNSVal16(srcport), InterfaceID, srcaddr->type); |
| 8029 | mDNSSendDNSMessage(m, &m->omsg, responseend, InterfaceID, mDNSNULL, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse); |
| 8030 | } |
| 8031 | } |
| 8032 | |
| 8033 | #if 0 |
| 8034 | mDNSlocal mDNSBool TrustedSource(const mDNS *const m, const mDNSAddr *const srcaddr) |
| 8035 | { |
| 8036 | DNSServer *s; |
| 8037 | (void)m; // Unused |
| 8038 | (void)srcaddr; // Unused |
| 8039 | for (s = m->DNSServers; s; s = s->next) |
| 8040 | if (mDNSSameAddress(srcaddr, &s->addr)) return(mDNStrue); |
| 8041 | return(mDNSfalse); |
| 8042 | } |
| 8043 | #endif |
| 8044 | |
| 8045 | struct UDPSocket_struct |
| 8046 | { |
| 8047 | mDNSIPPort port; // MUST BE FIRST FIELD -- mDNSCoreReceive expects every UDPSocket_struct to begin with mDNSIPPort port |
| 8048 | }; |
| 8049 | |
| 8050 | mDNSlocal DNSQuestion *ExpectingUnicastResponseForQuestion(const mDNS *const m, const mDNSIPPort port, const mDNSOpaque16 id, const DNSQuestion *const question, mDNSBool tcp) |
| 8051 | { |
| 8052 | DNSQuestion *q; |
| 8053 | for (q = m->Questions; q; q=q->next) |
| 8054 | { |
| 8055 | if (!tcp && !q->LocalSocket) continue; |
| 8056 | if (mDNSSameIPPort(tcp ? q->tcpSrcPort : q->LocalSocket->port, port) && |
| 8057 | mDNSSameOpaque16(q->TargetQID, id) && |
| 8058 | q->qtype == question->qtype && |
| 8059 | q->qclass == question->qclass && |
| 8060 | q->qnamehash == question->qnamehash && |
| 8061 | SameDomainName(&q->qname, &question->qname)) |
| 8062 | return(q); |
| 8063 | } |
| 8064 | return(mDNSNULL); |
| 8065 | } |
| 8066 | |
| 8067 | // This function is called when we receive a unicast response. This could be the case of a unicast response from the |
| 8068 | // DNS server or a response to the QU query. Hence, the cache record's InterfaceId can be both NULL or non-NULL (QU case) |
| 8069 | mDNSlocal DNSQuestion *ExpectingUnicastResponseForRecord(mDNS *const m, |
| 8070 | const mDNSAddr *const srcaddr, const mDNSBool SrcLocal, const mDNSIPPort port, const mDNSOpaque16 id, const CacheRecord *const rr, mDNSBool tcp) |
| 8071 | { |
| 8072 | DNSQuestion *q; |
| 8073 | (void)id; |
| 8074 | (void)srcaddr; |
| 8075 | |
| 8076 | for (q = m->Questions; q; q=q->next) |
| 8077 | { |
| 8078 | if (!q->DuplicateOf && ResourceRecordAnswersUnicastResponse(&rr->resrec, q)) |
| 8079 | { |
| 8080 | if (!mDNSOpaque16IsZero(q->TargetQID)) |
| 8081 | { |
| 8082 | debugf("ExpectingUnicastResponseForRecord msg->h.id %d q->TargetQID %d for %s" , mDNSVal16(id), mDNSVal16(q->TargetQID), CRDisplayString(m, rr)); |
| 8083 | |
| 8084 | if (mDNSSameOpaque16(q->TargetQID, id)) |
| 8085 | { |
| 8086 | mDNSIPPort srcp; |
| 8087 | if (!tcp) |
| 8088 | { |
| 8089 | srcp = q->LocalSocket ? q->LocalSocket->port : zeroIPPort; |
| 8090 | } |
| 8091 | else |
| 8092 | { |
| 8093 | srcp = q->tcpSrcPort; |
| 8094 | } |
| 8095 | if (mDNSSameIPPort(srcp, port)) return(q); |
| 8096 | |
| 8097 | // if (mDNSSameAddress(srcaddr, &q->Target)) return(mDNStrue); |
| 8098 | // if (q->LongLived && mDNSSameAddress(srcaddr, &q->servAddr)) return(mDNStrue); Shouldn't need this now that we have LLQType checking |
| 8099 | // if (TrustedSource(m, srcaddr)) return(mDNStrue); |
| 8100 | LogInfo("WARNING: Ignoring suspect uDNS response for %##s (%s) [q->Target %#a:%d] from %#a:%d %s" , |
| 8101 | q->qname.c, DNSTypeName(q->qtype), &q->Target, mDNSVal16(srcp), srcaddr, mDNSVal16(port), CRDisplayString(m, rr)); |
| 8102 | return(mDNSNULL); |
| 8103 | } |
| 8104 | } |
| 8105 | else |
| 8106 | { |
| 8107 | if (SrcLocal && q->ExpectUnicastResp && (mDNSu32)(m->timenow - q->ExpectUnicastResp) < (mDNSu32)(mDNSPlatformOneSecond*2)) |
| 8108 | return(q); |
| 8109 | } |
| 8110 | } |
| 8111 | } |
| 8112 | return(mDNSNULL); |
| 8113 | } |
| 8114 | |
| 8115 | // Certain data types need more space for in-memory storage than their in-packet rdlength would imply |
| 8116 | // Currently this applies only to rdata types containing more than one domainname, |
| 8117 | // or types where the domainname is not the last item in the structure. |
| 8118 | mDNSlocal mDNSu16 GetRDLengthMem(const ResourceRecord *const rr) |
| 8119 | { |
| 8120 | switch (rr->rrtype) |
| 8121 | { |
| 8122 | case kDNSType_SOA: return sizeof(rdataSOA); |
| 8123 | case kDNSType_RP: return sizeof(rdataRP); |
| 8124 | case kDNSType_PX: return sizeof(rdataPX); |
| 8125 | default: return rr->rdlength; |
| 8126 | } |
| 8127 | } |
| 8128 | |
| 8129 | mDNSexport CacheRecord *CreateNewCacheEntry(mDNS *const m, const mDNSu32 slot, CacheGroup *cg, mDNSs32 delay, mDNSBool Add, const mDNSAddr *sourceAddress) |
| 8130 | { |
| 8131 | CacheRecord *rr = mDNSNULL; |
| 8132 | mDNSu16 RDLength = GetRDLengthMem(&m->rec.r.resrec); |
| 8133 | |
| 8134 | if (!m->rec.r.resrec.InterfaceID) debugf("CreateNewCacheEntry %s" , CRDisplayString(m, &m->rec.r)); |
| 8135 | |
| 8136 | //if (RDLength > InlineCacheRDSize) |
| 8137 | // LogInfo("Rdata len %4d > InlineCacheRDSize %d %s", RDLength, InlineCacheRDSize, CRDisplayString(m, &m->rec.r)); |
| 8138 | |
| 8139 | if (!cg) cg = GetCacheGroup(m, slot, &m->rec.r.resrec); // If we don't have a CacheGroup for this name, make one now |
| 8140 | if (cg) rr = GetCacheRecord(m, cg, RDLength); // Make a cache record, being careful not to recycle cg |
| 8141 | if (!rr) NoCacheAnswer(m, &m->rec.r); |
| 8142 | else |
| 8143 | { |
| 8144 | RData *saveptr = rr->resrec.rdata; // Save the rr->resrec.rdata pointer |
| 8145 | *rr = m->rec.r; // Block copy the CacheRecord object |
| 8146 | rr->resrec.rdata = saveptr; // Restore rr->resrec.rdata after the structure assignment |
| 8147 | rr->resrec.name = cg->name; // And set rr->resrec.name to point into our CacheGroup header |
| 8148 | |
| 8149 | // We need to add the anonymous info before we call CacheRecordAdd so that |
| 8150 | // if it finds a matching question with this record, it bumps up the counters like |
| 8151 | // CurrentAnswers etc. Otherwise, when a cache entry gets removed, CacheRecordRmv |
| 8152 | // will complain. |
| 8153 | if (m->rec.r.resrec.AnonInfo) |
| 8154 | { |
| 8155 | rr->resrec.AnonInfo = m->rec.r.resrec.AnonInfo; |
| 8156 | m->rec.r.resrec.AnonInfo = mDNSNULL; |
| 8157 | } |
| 8158 | rr->DelayDelivery = delay; |
| 8159 | |
| 8160 | // If this is an oversized record with external storage allocated, copy rdata to external storage |
| 8161 | if (rr->resrec.rdata == (RData*)&rr->smallrdatastorage && RDLength > InlineCacheRDSize) |
| 8162 | LogMsg("rr->resrec.rdata == &rr->rdatastorage but length > InlineCacheRDSize %##s" , m->rec.r.resrec.name->c); |
| 8163 | else if (rr->resrec.rdata != (RData*)&rr->smallrdatastorage && RDLength <= InlineCacheRDSize) |
| 8164 | LogMsg("rr->resrec.rdata != &rr->rdatastorage but length <= InlineCacheRDSize %##s" , m->rec.r.resrec.name->c); |
| 8165 | if (RDLength > InlineCacheRDSize) |
| 8166 | mDNSPlatformMemCopy(rr->resrec.rdata, m->rec.r.resrec.rdata, sizeofRDataHeader + RDLength); |
| 8167 | |
| 8168 | rr->next = mDNSNULL; // Clear 'next' pointer |
| 8169 | rr->nsec = mDNSNULL; |
| 8170 | rr->soa = mDNSNULL; |
| 8171 | |
| 8172 | if (sourceAddress) |
| 8173 | rr->sourceAddress = *sourceAddress; |
| 8174 | |
| 8175 | if (!rr->resrec.InterfaceID) |
| 8176 | { |
| 8177 | m->rrcache_totalused_unicast += rr->resrec.rdlength; |
| 8178 | if (DNSSECRecordType(rr->resrec.rrtype)) |
| 8179 | BumpDNSSECStats(m, kStatsActionIncrement, kStatsTypeMemoryUsage, rr->resrec.rdlength); |
| 8180 | } |
| 8181 | |
| 8182 | if (Add) |
| 8183 | { |
| 8184 | *(cg->rrcache_tail) = rr; // Append this record to tail of cache slot list |
| 8185 | cg->rrcache_tail = &(rr->next); // Advance tail pointer |
| 8186 | CacheRecordAdd(m, rr); // CacheRecordAdd calls SetNextCacheCheckTimeForRecord(m, rr); for us |
| 8187 | } |
| 8188 | else |
| 8189 | { |
| 8190 | // Can't use the "cg->name" if we are not adding to the cache as the |
| 8191 | // CacheGroup may be released anytime if it is empty |
| 8192 | domainname *name = mDNSPlatformMemAllocate(DomainNameLength(cg->name)); |
| 8193 | if (name) |
| 8194 | { |
| 8195 | AssignDomainName(name, cg->name); |
| 8196 | rr->resrec.name = name; |
| 8197 | } |
| 8198 | else |
| 8199 | { |
| 8200 | ReleaseCacheRecord(m, rr); |
| 8201 | NoCacheAnswer(m, &m->rec.r); |
| 8202 | rr = mDNSNULL; |
| 8203 | } |
| 8204 | } |
| 8205 | } |
| 8206 | return(rr); |
| 8207 | } |
| 8208 | |
| 8209 | mDNSlocal void RefreshCacheRecord(mDNS *const m, CacheRecord *rr, mDNSu32 ttl) |
| 8210 | { |
| 8211 | rr->TimeRcvd = m->timenow; |
| 8212 | rr->resrec.rroriginalttl = ttl; |
| 8213 | rr->UnansweredQueries = 0; |
| 8214 | SetNextCacheCheckTimeForRecord(m, rr); |
| 8215 | } |
| 8216 | |
| 8217 | mDNSexport void GrantCacheExtensions(mDNS *const m, DNSQuestion *q, mDNSu32 lease) |
| 8218 | { |
| 8219 | CacheRecord *rr; |
| 8220 | CacheGroup *cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 8221 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 8222 | if (rr->CRActiveQuestion == q) |
| 8223 | { |
| 8224 | //LogInfo("GrantCacheExtensions: new lease %d / %s", lease, CRDisplayString(m, rr)); |
| 8225 | RefreshCacheRecord(m, rr, lease); |
| 8226 | } |
| 8227 | } |
| 8228 | |
| 8229 | mDNSlocal mDNSu32 GetEffectiveTTL(const uDNS_LLQType LLQType, mDNSu32 ttl) // TTL in seconds |
| 8230 | { |
| 8231 | if (LLQType == uDNS_LLQ_Entire) ttl = kLLQ_DefLease; |
| 8232 | else if (LLQType == uDNS_LLQ_Events) |
| 8233 | { |
| 8234 | // If the TTL is -1 for uDNS LLQ event packet, that means "remove" |
| 8235 | if (ttl == 0xFFFFFFFF) ttl = 0; |
| 8236 | else ttl = kLLQ_DefLease; |
| 8237 | } |
| 8238 | else // else not LLQ (standard uDNS response) |
| 8239 | { |
| 8240 | // The TTL is already capped to a maximum value in GetLargeResourceRecord, but just to be extra safe we |
| 8241 | // also do this check here to make sure we can't get overflow below when we add a quarter to the TTL |
| 8242 | if (ttl > 0x60000000UL / mDNSPlatformOneSecond) ttl = 0x60000000UL / mDNSPlatformOneSecond; |
| 8243 | |
| 8244 | ttl = RRAdjustTTL(ttl); |
| 8245 | |
| 8246 | // For mDNS, TTL zero means "delete this record" |
| 8247 | // For uDNS, TTL zero means: this data is true at this moment, but don't cache it. |
| 8248 | // For the sake of network efficiency, we impose a minimum effective TTL of 15 seconds. |
| 8249 | // This means that we'll do our 80, 85, 90, 95% queries at 12.00, 12.75, 13.50, 14.25 seconds |
| 8250 | // respectively, and then if we get no response, delete the record from the cache at 15 seconds. |
| 8251 | // This gives the server up to three seconds to respond between when we send our 80% query at 12 seconds |
| 8252 | // and when we delete the record at 15 seconds. Allowing cache lifetimes less than 15 seconds would |
| 8253 | // (with the current code) result in the server having even less than three seconds to respond |
| 8254 | // before we deleted the record and reported a "remove" event to any active questions. |
| 8255 | // Furthermore, with the current code, if we were to allow a TTL of less than 2 seconds |
| 8256 | // then things really break (e.g. we end up making a negative cache entry). |
| 8257 | // In the future we may want to revisit this and consider properly supporting non-cached (TTL=0) uDNS answers. |
| 8258 | if (ttl < 15) ttl = 15; |
| 8259 | } |
| 8260 | |
| 8261 | return ttl; |
| 8262 | } |
| 8263 | |
| 8264 | // When the response does not match the question directly, we still want to cache them sometimes. The current response is |
| 8265 | // in m->rec. |
| 8266 | mDNSlocal mDNSBool IsResponseAcceptable(mDNS *const m, const CacheRecord *crlist, DNSQuestion *q, mDNSBool *nseclist) |
| 8267 | { |
| 8268 | CacheRecord *const newcr = &m->rec.r; |
| 8269 | ResourceRecord *rr = &newcr->resrec; |
| 8270 | const CacheRecord *cr; |
| 8271 | |
| 8272 | *nseclist = mDNSfalse; |
| 8273 | for (cr = crlist; cr != (CacheRecord*)1; cr = cr->NextInCFList) |
| 8274 | { |
| 8275 | domainname *target = GetRRDomainNameTarget(&cr->resrec); |
| 8276 | // When we issue a query for A record, the response might contain both a CNAME and A records. Only the CNAME would |
| 8277 | // match the question and we already created a cache entry in the previous pass of this loop. Now when we process |
| 8278 | // the A record, it does not match the question because the record name here is the CNAME. Hence we try to |
| 8279 | // match with the previous records to make it an AcceptableResponse. We have to be careful about setting the |
| 8280 | // DNSServer value that we got in the previous pass. This can happen for other record types like SRV also. |
| 8281 | |
| 8282 | if (target && cr->resrec.rdatahash == rr->namehash && SameDomainName(target, rr->name)) |
| 8283 | { |
| 8284 | LogInfo("IsResponseAcceptable: Found a matching entry for %##s in the CacheFlushRecords %s" , rr->name->c, CRDisplayString(m, cr)); |
| 8285 | return (mDNStrue); |
| 8286 | } |
| 8287 | } |
| 8288 | |
| 8289 | // Either the question requires validation or we are validating a response with DNSSEC in which case |
| 8290 | // we need to accept the RRSIGs also so that we can validate the response. It is also possible that |
| 8291 | // we receive NSECs for our query which does not match the qname and we need to cache in that case |
| 8292 | // too. nseclist is set if they have to be cached as part of the negative cache record. |
| 8293 | if (q && DNSSECQuestion(q)) |
| 8294 | { |
| 8295 | mDNSBool same = SameDomainName(&q->qname, rr->name); |
| 8296 | if (same && (q->qtype == rr->rrtype || rr->rrtype == kDNSType_CNAME)) |
| 8297 | { |
| 8298 | LogInfo("IsResponseAcceptable: Accepting, same name and qtype %s, CR %s" , DNSTypeName(q->qtype), |
| 8299 | CRDisplayString(m, newcr)); |
| 8300 | return mDNStrue; |
| 8301 | } |
| 8302 | // We cache RRSIGS if it covers the question type or NSEC. If it covers a NSEC, |
| 8303 | // "nseclist" is set |
| 8304 | if (rr->rrtype == kDNSType_RRSIG) |
| 8305 | { |
| 8306 | RDataBody2 *const rdb = (RDataBody2 *)newcr->smallrdatastorage.data; |
| 8307 | rdataRRSig *rrsig = &rdb->rrsig; |
| 8308 | mDNSu16 typeCovered = swap16(rrsig->typeCovered); |
| 8309 | |
| 8310 | // Note the ordering. If we are looking up the NSEC record, then the RRSIG's typeCovered |
| 8311 | // would match the qtype and they are cached normally as they are not used to prove the |
| 8312 | // non-existence of any name. In that case, it is like any other normal dnssec validation |
| 8313 | // and hence nseclist should not be set. |
| 8314 | |
| 8315 | if (same && ((typeCovered == q->qtype) || (typeCovered == kDNSType_CNAME))) |
| 8316 | { |
| 8317 | LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches question type %s" , CRDisplayString(m, newcr), |
| 8318 | DNSTypeName(q->qtype)); |
| 8319 | return mDNStrue; |
| 8320 | } |
| 8321 | else if (typeCovered == kDNSType_NSEC || typeCovered == kDNSType_NSEC3) |
| 8322 | { |
| 8323 | LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches %s type (nseclist = 1)" , CRDisplayString(m, newcr), DNSTypeName(typeCovered)); |
| 8324 | *nseclist = mDNStrue; |
| 8325 | return mDNStrue; |
| 8326 | } |
| 8327 | else if (typeCovered == kDNSType_SOA) |
| 8328 | { |
| 8329 | LogInfo("IsResponseAcceptable: Accepting RRSIG %s matches SOA type (nseclist = 1)" , CRDisplayString(m, newcr)); |
| 8330 | *nseclist = mDNStrue; |
| 8331 | return mDNStrue; |
| 8332 | } |
| 8333 | else return mDNSfalse; |
| 8334 | } |
| 8335 | if (rr->rrtype == kDNSType_NSEC) |
| 8336 | { |
| 8337 | if (!UNICAST_NSEC(rr)) |
| 8338 | { |
| 8339 | LogMsg("IsResponseAcceptable: ERROR!! Not a unicast NSEC %s" , CRDisplayString(m, newcr)); |
| 8340 | return mDNSfalse; |
| 8341 | } |
| 8342 | LogInfo("IsResponseAcceptable: Accepting NSEC %s (nseclist = 1)" , CRDisplayString(m, newcr)); |
| 8343 | *nseclist = mDNStrue; |
| 8344 | return mDNStrue; |
| 8345 | } |
| 8346 | if (rr->rrtype == kDNSType_SOA) |
| 8347 | { |
| 8348 | LogInfo("IsResponseAcceptable: Accepting SOA %s (nseclist = 1)" , CRDisplayString(m, newcr)); |
| 8349 | *nseclist = mDNStrue; |
| 8350 | return mDNStrue; |
| 8351 | } |
| 8352 | else if (rr->rrtype == kDNSType_NSEC3) |
| 8353 | { |
| 8354 | LogInfo("IsResponseAcceptable: Accepting NSEC3 %s (nseclist = 1)" , CRDisplayString(m, newcr)); |
| 8355 | *nseclist = mDNStrue; |
| 8356 | return mDNStrue; |
| 8357 | } |
| 8358 | } |
| 8359 | return mDNSfalse; |
| 8360 | } |
| 8361 | |
| 8362 | mDNSlocal void FreeNSECRecords(mDNS *const m, CacheRecord *NSECRecords) |
| 8363 | { |
| 8364 | CacheRecord *rp, *next; |
| 8365 | |
| 8366 | for (rp = NSECRecords; rp; rp = next) |
| 8367 | { |
| 8368 | next = rp->next; |
| 8369 | ReleaseCacheRecord(m, rp); |
| 8370 | } |
| 8371 | } |
| 8372 | |
| 8373 | // If we received zero DNSSEC records even when the DO/EDNS0 bit was set, we need to provide this |
| 8374 | // information to ValidatingResponse question to indicate the DNSSEC status to the application |
| 8375 | mDNSlocal void mDNSCoreReceiveNoDNSSECAnswers(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *dstaddr, |
| 8376 | mDNSIPPort dstport, const mDNSInterfaceID InterfaceID) |
| 8377 | { |
| 8378 | int i; |
| 8379 | const mDNSu8 *ptr = response->data; |
| 8380 | |
| 8381 | for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) |
| 8382 | { |
| 8383 | DNSQuestion pktq; |
| 8384 | DNSQuestion *qptr = mDNSNULL; |
| 8385 | ptr = getQuestion(response, ptr, end, InterfaceID, &pktq); |
| 8386 | if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &pktq, !dstaddr)) && |
| 8387 | qptr->ValidatingResponse) |
| 8388 | { |
| 8389 | DNSQuestion *next, *q; |
| 8390 | |
| 8391 | if (qptr->DuplicateOf) |
| 8392 | LogMsg("mDNSCoreReceiveNoDNSSECAnswers: ERROR!! qptr %##s (%s) Duplicate question matching response" , qptr->qname.c, DNSTypeName(qptr->qtype)); |
| 8393 | |
| 8394 | // Be careful to call the callback for duplicate questions first and then the original |
| 8395 | // question. If we called the callback on the original question, it could stop and |
| 8396 | // a duplicate question would become the original question. |
| 8397 | mDNS_DropLockBeforeCallback(); // Allow client (and us) to legally make mDNS API calls |
| 8398 | for (q = qptr->next ; q && q != m->NewQuestions; q = next) |
| 8399 | { |
| 8400 | next = q->next; |
| 8401 | if (q->DuplicateOf == qptr) |
| 8402 | { |
| 8403 | if (q->ValidatingResponse) |
| 8404 | LogInfo("mDNSCoreReceiveNoDNSSECAnswers: qptr %##s (%s) Duplicate question found" , q->qname.c, DNSTypeName(q->qtype)); |
| 8405 | else |
| 8406 | LogMsg("mDNSCoreReceiveNoDNSSECAnswers: ERROR!! qptr %##s (%s) Duplicate question not ValidatingResponse" , q->qname.c, DNSTypeName(q->qtype)); |
| 8407 | if (q->QuestionCallback) |
| 8408 | q->QuestionCallback(m, q, mDNSNULL, QC_nodnssec); |
| 8409 | } |
| 8410 | } |
| 8411 | if (qptr->QuestionCallback) |
| 8412 | qptr->QuestionCallback(m, qptr, mDNSNULL, QC_nodnssec); |
| 8413 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 8414 | } |
| 8415 | } |
| 8416 | } |
| 8417 | |
| 8418 | mDNSlocal void mDNSCoreReceiveNoUnicastAnswers(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, const mDNSAddr *dstaddr, |
| 8419 | mDNSIPPort dstport, const mDNSInterfaceID InterfaceID, uDNS_LLQType LLQType, mDNSu8 rcode, CacheRecord *NSECRecords) |
| 8420 | { |
| 8421 | int i; |
| 8422 | const mDNSu8 *ptr = response->data; |
| 8423 | CacheRecord *SOARecord = mDNSNULL; |
| 8424 | |
| 8425 | for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) |
| 8426 | { |
| 8427 | DNSQuestion q; |
| 8428 | DNSQuestion *qptr = mDNSNULL; |
| 8429 | ptr = getQuestion(response, ptr, end, InterfaceID, &q); |
| 8430 | if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr))) |
| 8431 | { |
| 8432 | CacheRecord *rr, *neg = mDNSNULL; |
| 8433 | CacheGroup *cg = CacheGroupForName(m, q.qnamehash, &q.qname); |
| 8434 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 8435 | if (SameNameRecordAnswersQuestion(&rr->resrec, qptr)) |
| 8436 | { |
| 8437 | // 1. If we got a fresh answer to this query, then don't need to generate a negative entry |
| 8438 | if (RRExpireTime(rr) - m->timenow > 0) break; |
| 8439 | // 2. If we already had a negative entry, keep track of it so we can resurrect it instead of creating a new one |
| 8440 | if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) neg = rr; |
| 8441 | } |
| 8442 | // When we're doing parallel unicast and multicast queries for dot-local names (for supporting Microsoft |
| 8443 | // Active Directory sites) we don't want to waste memory making negative cache entries for all the unicast answers. |
| 8444 | // Otherwise we just fill up our cache with negative entries for just about every single multicast name we ever look up |
| 8445 | // (since the Microsoft Active Directory server is going to assert that pretty much every single multicast name doesn't exist). |
| 8446 | // This is not only a waste of memory, but there's also the problem of those negative entries confusing us later -- e.g. we |
| 8447 | // suppress sending our mDNS query packet because we think we already have a valid (negative) answer to that query in our cache. |
| 8448 | // The one exception is that we *DO* want to make a negative cache entry for "local. SOA", for the (common) case where we're |
| 8449 | // *not* on a Microsoft Active Directory network, and there is no authoritative server for "local". Note that this is not |
| 8450 | // in conflict with the mDNS spec, because that spec says, "Multicast DNS Zones have no SOA record," so it's okay to cache |
| 8451 | // negative answers for "local. SOA" from a uDNS server, because the mDNS spec already says that such records do not exist :-) |
| 8452 | // |
| 8453 | // By suppressing negative responses, it might take longer to timeout a .local question as it might be expecting a |
| 8454 | // response e.g., we deliver a positive "A" response and suppress negative "AAAA" response and the upper layer may |
| 8455 | // be waiting longer to get the AAAA response before returning the "A" response to the application. To handle this |
| 8456 | // case without creating the negative cache entries, we generate a negative response and let the layer above us |
| 8457 | // do the appropriate thing. This negative response is also needed for appending new search domains. |
| 8458 | if (!InterfaceID && q.qtype != kDNSType_SOA && IsLocalDomain(&q.qname)) |
| 8459 | { |
| 8460 | if (!rr) |
| 8461 | { |
| 8462 | LogInfo("mDNSCoreReceiveNoUnicastAnswers: Generate negative response for %##s (%s)" , q.qname.c, DNSTypeName(q.qtype)); |
| 8463 | m->CurrentQuestion = qptr; |
| 8464 | // We are not creating a cache record in this case, we need to pass back |
| 8465 | // the error we got so that the proxy code can return the right one to |
| 8466 | // the application |
| 8467 | if (qptr->ProxyQuestion) |
| 8468 | qptr->responseFlags = response->h.flags; |
| 8469 | GenerateNegativeResponse(m, mDNSInterface_Any, QC_forceresponse); |
| 8470 | m->CurrentQuestion = mDNSNULL; |
| 8471 | } |
| 8472 | else |
| 8473 | { |
| 8474 | LogInfo("mDNSCoreReceiveNoUnicastAnswers: Skipping check and not creating a negative cache entry for %##s (%s)" , q.qname.c, DNSTypeName(q.qtype)); |
| 8475 | } |
| 8476 | } |
| 8477 | else |
| 8478 | { |
| 8479 | if (!rr) |
| 8480 | { |
| 8481 | // We start off assuming a negative caching TTL of 60 seconds |
| 8482 | // but then look to see if we can find an SOA authority record to tell us a better value we should be using |
| 8483 | mDNSu32 negttl = 60; |
| 8484 | int repeat = 0; |
| 8485 | const domainname *name = &q.qname; |
| 8486 | mDNSu32 hash = q.qnamehash; |
| 8487 | |
| 8488 | // Special case for our special Microsoft Active Directory "local SOA" check. |
| 8489 | // Some cheap home gateways don't include an SOA record in the authority section when |
| 8490 | // they send negative responses, so we don't know how long to cache the negative result. |
| 8491 | // Because we don't want to keep hitting the root name servers with our query to find |
| 8492 | // if we're on a network using Microsoft Active Directory using "local" as a private |
| 8493 | // internal top-level domain, we make sure to cache the negative result for at least one day. |
| 8494 | if (q.qtype == kDNSType_SOA && SameDomainName(&q.qname, &localdomain)) negttl = 60 * 60 * 24; |
| 8495 | |
| 8496 | // If we're going to make (or update) a negative entry, then look for the appropriate TTL from the SOA record |
| 8497 | if (response->h.numAuthorities && (ptr = LocateAuthorities(response, end)) != mDNSNULL) |
| 8498 | { |
| 8499 | ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); |
| 8500 | if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_SOA) |
| 8501 | { |
| 8502 | CacheGroup *cgSOA = CacheGroupForRecord(m, &m->rec.r.resrec); |
| 8503 | const rdataSOA *const soa = (const rdataSOA *)m->rec.r.resrec.rdata->u.data; |
| 8504 | mDNSu32 ttl_s = soa->min; |
| 8505 | // We use the lesser of the SOA.MIN field and the SOA record's TTL, *except* |
| 8506 | // for the SOA record for ".", where the record is reported as non-cacheable |
| 8507 | // (TTL zero) for some reason, so in this case we just take the SOA record's TTL as-is |
| 8508 | if (ttl_s > m->rec.r.resrec.rroriginalttl && m->rec.r.resrec.name->c[0]) |
| 8509 | ttl_s = m->rec.r.resrec.rroriginalttl; |
| 8510 | if (negttl < ttl_s) negttl = ttl_s; |
| 8511 | |
| 8512 | // Create the SOA record as we may have to return this to the questions |
| 8513 | // that we are acting as a proxy for currently or in the future. |
| 8514 | SOARecord = CreateNewCacheEntry(m, HashSlotFromNameHash(m->rec.r.resrec.namehash), cgSOA, 1, mDNSfalse, mDNSNULL); |
| 8515 | |
| 8516 | // Special check for SOA queries: If we queried for a.b.c.d.com, and got no answer, |
| 8517 | // with an Authority Section SOA record for d.com, then this is a hint that the authority |
| 8518 | // is d.com, and consequently SOA records b.c.d.com and c.d.com don't exist either. |
| 8519 | // To do this we set the repeat count so the while loop below will make a series of negative cache entries for us |
| 8520 | // |
| 8521 | // For ProxyQuestions, we don't do this as we need to create additional SOA records to cache them |
| 8522 | // along with the negative cache record. For simplicity, we don't create the additional records. |
| 8523 | if (!qptr->ProxyQuestion && q.qtype == kDNSType_SOA) |
| 8524 | { |
| 8525 | int qcount = CountLabels(&q.qname); |
| 8526 | int scount = CountLabels(m->rec.r.resrec.name); |
| 8527 | if (qcount - 1 > scount) |
| 8528 | if (SameDomainName(SkipLeadingLabels(&q.qname, qcount - scount), m->rec.r.resrec.name)) |
| 8529 | repeat = qcount - 1 - scount; |
| 8530 | } |
| 8531 | } |
| 8532 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 8533 | } |
| 8534 | |
| 8535 | // If we already had a negative entry in the cache, then we double our existing negative TTL. This is to avoid |
| 8536 | // the case where the record doesn't exist (e.g. particularly for things like our lb._dns-sd._udp.<domain> query), |
| 8537 | // and the server returns no SOA record (or an SOA record with a small MIN TTL) so we assume a TTL |
| 8538 | // of 60 seconds, and we end up polling the server every minute for a record that doesn't exist. |
| 8539 | // With this fix in place, when this happens, we double the effective TTL each time (up to one hour), |
| 8540 | // so that we back off our polling rate and don't keep hitting the server continually. |
| 8541 | if (neg) |
| 8542 | { |
| 8543 | if (negttl < neg->resrec.rroriginalttl * 2) |
| 8544 | negttl = neg->resrec.rroriginalttl * 2; |
| 8545 | if (negttl > 3600) |
| 8546 | negttl = 3600; |
| 8547 | } |
| 8548 | |
| 8549 | negttl = GetEffectiveTTL(LLQType, negttl); // Add 25% grace period if necessary |
| 8550 | |
| 8551 | // If we already had a negative cache entry just update it, else make one or more new negative cache entries. |
| 8552 | if (neg) |
| 8553 | { |
| 8554 | LogInfo("mDNSCoreReceiveNoUnicastAnswers: Renewing negative TTL from %d to %d %s" , neg->resrec.rroriginalttl, negttl, CRDisplayString(m, neg)); |
| 8555 | RefreshCacheRecord(m, neg, negttl); |
| 8556 | // When we created the cache for the first time and answered the question, the question's |
| 8557 | // interval was set to MaxQuestionInterval. If the cache is about to expire and we are resending |
| 8558 | // the queries, the interval should still be at MaxQuestionInterval. If the query is being |
| 8559 | // restarted (setting it to InitialQuestionInterval) for other reasons e.g., wakeup, |
| 8560 | // we should reset its question interval here to MaxQuestionInterval. |
| 8561 | ResetQuestionState(m, qptr); |
| 8562 | if (DNSSECQuestion(qptr)) |
| 8563 | neg->CRDNSSECQuestion = 1; |
| 8564 | // Update the NSEC records again. |
| 8565 | // TBD: Need to purge and revalidate if the cached NSECS and the new set are not same. |
| 8566 | if (NSECRecords) |
| 8567 | { |
| 8568 | if (!AddNSECSForCacheRecord(m, NSECRecords, neg, rcode)) |
| 8569 | { |
| 8570 | // We might just have an SOA record for zones that are not signed and hence don't log |
| 8571 | // this as an error |
| 8572 | LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord failed to add NSEC for negcr %s during refresh" , CRDisplayString(m, neg)); |
| 8573 | FreeNSECRecords(m, NSECRecords); |
| 8574 | neg->CRDNSSECQuestion = 0; |
| 8575 | } |
| 8576 | NSECRecords = mDNSNULL; |
| 8577 | } |
| 8578 | if (SOARecord) |
| 8579 | { |
| 8580 | if (neg->soa) |
| 8581 | ReleaseCacheRecord(m, neg->soa); |
| 8582 | neg->soa = SOARecord; |
| 8583 | SOARecord = mDNSNULL; |
| 8584 | } |
| 8585 | } |
| 8586 | else while (1) |
| 8587 | { |
| 8588 | CacheRecord *negcr; |
| 8589 | debugf("mDNSCoreReceiveNoUnicastAnswers making negative cache entry TTL %d for %##s (%s)" , negttl, name->c, DNSTypeName(q.qtype)); |
| 8590 | MakeNegativeCacheRecord(m, &m->rec.r, name, hash, q.qtype, q.qclass, negttl, mDNSInterface_Any, qptr->qDNSServer); |
| 8591 | m->rec.r.responseFlags = response->h.flags; |
| 8592 | // We create SOA records above which might create new cache groups. Earlier |
| 8593 | // in the function we looked up the cache group for the name and it could have |
| 8594 | // been NULL. If we pass NULL cg to new cache entries that we create below, |
| 8595 | // it will create additional cache groups for the same name. To avoid that, |
| 8596 | // look up the cache group again to re-initialize cg again. |
| 8597 | cg = CacheGroupForName(m, hash, name); |
| 8598 | if (NSECRecords && DNSSECQuestion(qptr)) |
| 8599 | { |
| 8600 | // Create the cache entry with delay and then add the NSEC records |
| 8601 | // to it and add it immediately. |
| 8602 | negcr = CreateNewCacheEntry(m, HashSlotFromNameHash(hash), cg, 1, mDNStrue, mDNSNULL); |
| 8603 | if (negcr) |
| 8604 | { |
| 8605 | negcr->CRDNSSECQuestion = 0; |
| 8606 | if (!AddNSECSForCacheRecord(m, NSECRecords, negcr, rcode)) |
| 8607 | { |
| 8608 | LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord failed to add NSEC for negcr %s" , |
| 8609 | CRDisplayString(m, negcr)); |
| 8610 | FreeNSECRecords(m, NSECRecords); |
| 8611 | } |
| 8612 | else |
| 8613 | { |
| 8614 | negcr->CRDNSSECQuestion = 1; |
| 8615 | LogInfo("mDNSCoreReceiveNoUnicastAnswers: AddNSECSForCacheRecord added neg NSEC for %s" , CRDisplayString(m, negcr)); |
| 8616 | } |
| 8617 | NSECRecords = mDNSNULL; |
| 8618 | negcr->DelayDelivery = 0; |
| 8619 | CacheRecordDeferredAdd(m, negcr); |
| 8620 | } |
| 8621 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 8622 | break; |
| 8623 | } |
| 8624 | else |
| 8625 | { |
| 8626 | // Need to add with a delay so that we can tag the SOA record |
| 8627 | negcr = CreateNewCacheEntry(m, HashSlotFromNameHash(hash), cg, 1, mDNStrue, mDNSNULL); |
| 8628 | if (negcr) |
| 8629 | { |
| 8630 | negcr->CRDNSSECQuestion = 0; |
| 8631 | if (DNSSECQuestion(qptr)) |
| 8632 | negcr->CRDNSSECQuestion = 1; |
| 8633 | negcr->DelayDelivery = 0; |
| 8634 | |
| 8635 | if (SOARecord) |
| 8636 | { |
| 8637 | if (negcr->soa) |
| 8638 | ReleaseCacheRecord(m, negcr->soa); |
| 8639 | negcr->soa = SOARecord; |
| 8640 | SOARecord = mDNSNULL; |
| 8641 | } |
| 8642 | CacheRecordDeferredAdd(m, negcr); |
| 8643 | } |
| 8644 | } |
| 8645 | m->rec.r.responseFlags = zeroID; |
| 8646 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 8647 | if (!repeat) break; |
| 8648 | repeat--; |
| 8649 | name = (const domainname *)(name->c + 1 + name->c[0]); |
| 8650 | hash = DomainNameHashValue(name); |
| 8651 | } |
| 8652 | } |
| 8653 | } |
| 8654 | } |
| 8655 | } |
| 8656 | if (NSECRecords) { LogInfo("mDNSCoreReceiveNoUnicastAnswers: NSECRecords not used" ); FreeNSECRecords(m, NSECRecords); } |
| 8657 | if (SOARecord) { LogInfo("mDNSCoreReceiveNoUnicastAnswers: SOARecord not used" ); ReleaseCacheRecord(m, SOARecord); } |
| 8658 | } |
| 8659 | |
| 8660 | mDNSlocal void mDNSCorePrintStoredProxyRecords(mDNS *const m) |
| 8661 | { |
| 8662 | AuthRecord *rrPtr = mDNSNULL; |
| 8663 | LogSPS("Stored Proxy records :" ); |
| 8664 | for (rrPtr = m->SPSRRSet; rrPtr; rrPtr = rrPtr->next) |
| 8665 | { |
| 8666 | LogSPS("%s" , ARDisplayString(m, rrPtr)); |
| 8667 | } |
| 8668 | } |
| 8669 | |
| 8670 | mDNSlocal mDNSBool mDNSCoreRegisteredProxyRecord(mDNS *const m, AuthRecord *rr) |
| 8671 | { |
| 8672 | AuthRecord *rrPtr = mDNSNULL; |
| 8673 | |
| 8674 | for (rrPtr = m->SPSRRSet; rrPtr; rrPtr = rrPtr->next) |
| 8675 | { |
| 8676 | if (IdenticalResourceRecord(&rrPtr->resrec, &rr->resrec)) |
| 8677 | { |
| 8678 | LogSPS("mDNSCoreRegisteredProxyRecord: Ignoring packet registered with sleep proxy : %s " , ARDisplayString(m, rr)); |
| 8679 | return mDNStrue; |
| 8680 | } |
| 8681 | } |
| 8682 | mDNSCorePrintStoredProxyRecords(m); |
| 8683 | return mDNSfalse; |
| 8684 | } |
| 8685 | |
| 8686 | mDNSlocal CacheRecord* mDNSCoreReceiveCacheCheck(mDNS *const m, const DNSMessage *const response, uDNS_LLQType LLQType, |
| 8687 | const mDNSu32 slot, CacheGroup *cg, DNSQuestion *unicastQuestion, CacheRecord ***cfp, CacheRecord **NSECCachePtr, |
| 8688 | mDNSInterfaceID InterfaceID) |
| 8689 | { |
| 8690 | CacheRecord *rr; |
| 8691 | CacheRecord **cflocal = *cfp; |
| 8692 | |
| 8693 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 8694 | { |
| 8695 | mDNSBool match; |
| 8696 | // Resource record received via unicast, the resGroupID should match ? |
| 8697 | if (!InterfaceID) |
| 8698 | { |
| 8699 | mDNSu16 id1 = (rr->resrec.rDNSServer ? rr->resrec.rDNSServer->resGroupID : 0); |
| 8700 | mDNSu16 id2 = (m->rec.r.resrec.rDNSServer ? m->rec.r.resrec.rDNSServer->resGroupID : 0); |
| 8701 | match = (id1 == id2); |
| 8702 | } |
| 8703 | else |
| 8704 | match = (rr->resrec.InterfaceID == InterfaceID); |
| 8705 | // If we found this exact resource record, refresh its TTL |
| 8706 | if (match && IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec)) |
| 8707 | { |
| 8708 | if (m->rec.r.resrec.rdlength > InlineCacheRDSize) |
| 8709 | verbosedebugf("mDNSCoreReceiveCacheCheck: Found record size %5d interface %p already in cache: %s" , |
| 8710 | m->rec.r.resrec.rdlength, InterfaceID, CRDisplayString(m, &m->rec.r)); |
| 8711 | |
| 8712 | if (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) |
| 8713 | { |
| 8714 | // If this packet record has the kDNSClass_UniqueRRSet flag set, then add it to our cache flushing list |
| 8715 | if (rr->NextInCFList == mDNSNULL && *cfp != &rr->NextInCFList && LLQType != uDNS_LLQ_Events) |
| 8716 | { |
| 8717 | *cflocal = rr; |
| 8718 | cflocal = &rr->NextInCFList; |
| 8719 | *cflocal = (CacheRecord*)1; |
| 8720 | *cfp = &rr->NextInCFList; |
| 8721 | } |
| 8722 | |
| 8723 | // If this packet record is marked unique, and our previous cached copy was not, then fix it |
| 8724 | if (!(rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask)) |
| 8725 | { |
| 8726 | DNSQuestion *q; |
| 8727 | for (q = m->Questions; q; q=q->next) |
| 8728 | { |
| 8729 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 8730 | q->UniqueAnswers++; |
| 8731 | } |
| 8732 | rr->resrec.RecordType = m->rec.r.resrec.RecordType; |
| 8733 | } |
| 8734 | } |
| 8735 | |
| 8736 | if (!SameRDataBody(&m->rec.r.resrec, &rr->resrec.rdata->u, SameDomainNameCS)) |
| 8737 | { |
| 8738 | // If the rdata of the packet record differs in name capitalization from the record in our cache |
| 8739 | // then mDNSPlatformMemSame will detect this. In this case, throw the old record away, so that clients get |
| 8740 | // a 'remove' event for the record with the old capitalization, and then an 'add' event for the new one. |
| 8741 | // <rdar://problem/4015377> mDNS -F returns the same domain multiple times with different casing |
| 8742 | rr->resrec.rroriginalttl = 0; |
| 8743 | rr->TimeRcvd = m->timenow; |
| 8744 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 8745 | SetNextCacheCheckTimeForRecord(m, rr); |
| 8746 | LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change old: %s" , CRDisplayString(m, rr)); |
| 8747 | LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change new: %s" , CRDisplayString(m, &m->rec.r)); |
| 8748 | LogInfo("mDNSCoreReceiveCacheCheck: Discarding due to domainname case change in %d slot %3d in %d %d" , |
| 8749 | NextCacheCheckEvent(rr) - m->timenow, slot, m->rrcache_nextcheck[slot] - m->timenow, m->NextCacheCheck - m->timenow); |
| 8750 | // DO NOT break out here -- we want to continue as if we never found it |
| 8751 | } |
| 8752 | else if (!IdenticalAnonInfo(m->rec.r.resrec.AnonInfo, rr->resrec.AnonInfo)) |
| 8753 | { |
| 8754 | // If the NSEC3 record changed, a few possibilities |
| 8755 | // |
| 8756 | // 1) the peer reinitialized e.g., after network change and still part of the |
| 8757 | // same set. |
| 8758 | // 2) the peer went to a different set but we did not see the goodbyes. If we just |
| 8759 | // update the nsec3 record, it would be incorrect. Flush the cache so that we |
| 8760 | // can deliver a RMV followed by ADD. |
| 8761 | // 3) if the peer is ourselves and we see the goodbye when moving to a different set |
| 8762 | // and so we flush the cache and create a new cache record with the new set information. |
| 8763 | // Now we move back to the original set. In this case, we can't just update the |
| 8764 | // NSEC3 record alone. We need to flush so that we can deliver an RMV followed by ADD |
| 8765 | // when we create the new cache entry. |
| 8766 | // |
| 8767 | // Note: For case (1), we could avoid flushing the cache but we can't tell the difference |
| 8768 | // from the other cases. |
| 8769 | rr->resrec.rroriginalttl = 0; |
| 8770 | rr->TimeRcvd = m->timenow; |
| 8771 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 8772 | SetNextCacheCheckTimeForRecord(m, rr); |
| 8773 | LogInfo("mDNSCoreReceiveCacheCheck: AnonInfo changed for %s" , CRDisplayString(m, rr)); |
| 8774 | // DO NOT break out here -- we want to continue as if we never found it. When we return |
| 8775 | // from this function, we will create a new cache entry with the new NSEC3 record |
| 8776 | } |
| 8777 | else if (m->rec.r.resrec.rroriginalttl > 0) |
| 8778 | { |
| 8779 | DNSQuestion *q; |
| 8780 | |
| 8781 | m->mDNSStats.CacheRefreshed++; |
| 8782 | |
| 8783 | if (rr->resrec.rroriginalttl == 0) debugf("uDNS rescuing %s" , CRDisplayString(m, rr)); |
| 8784 | RefreshCacheRecord(m, rr, m->rec.r.resrec.rroriginalttl); |
| 8785 | rr->responseFlags = response->h.flags; |
| 8786 | |
| 8787 | // If we may have NSEC records returned with the answer (which we don't know yet as it |
| 8788 | // has not been processed), we need to cache them along with the first cache |
| 8789 | // record in the list that answers the question so that it can be used for validation |
| 8790 | // later. The "type" check below is to make sure that we cache on the cache record |
| 8791 | // that would answer the question. It is possible that we might cache additional things |
| 8792 | // e.g., MX question might cache A records also, and we want to cache the NSEC on |
| 8793 | // the record that answers the question. |
| 8794 | if (response->h.numAnswers && unicastQuestion && unicastQuestion->qtype == rr->resrec.rrtype |
| 8795 | && !(*NSECCachePtr)) |
| 8796 | { |
| 8797 | LogInfo("mDNSCoreReceiveCacheCheck: rescuing RR %s" , CRDisplayString(m, rr)); |
| 8798 | *NSECCachePtr = rr; |
| 8799 | } |
| 8800 | // We have to reset the question interval to MaxQuestionInterval so that we don't keep |
| 8801 | // polling the network once we get a valid response back. For the first time when a new |
| 8802 | // cache entry is created, AnswerCurrentQuestionWithResourceRecord does that. |
| 8803 | // Subsequently, if we reissue questions from within the mDNSResponder e.g., DNS server |
| 8804 | // configuration changed, without flushing the cache, we reset the question interval here. |
| 8805 | // Currently, we do this for for both multicast and unicast questions as long as the record |
| 8806 | // type is unique. For unicast, resource record is always unique and for multicast it is |
| 8807 | // true for records like A etc. but not for PTR. |
| 8808 | if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) |
| 8809 | { |
| 8810 | for (q = m->Questions; q; q=q->next) |
| 8811 | { |
| 8812 | if (!q->DuplicateOf && !q->LongLived && |
| 8813 | ActiveQuestion(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 8814 | { |
| 8815 | ResetQuestionState(m, q); |
| 8816 | debugf("mDNSCoreReceiveCacheCheck: Set MaxQuestionInterval for %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 8817 | break; // Why break here? Aren't there other questions we might want to look at?-- SC July 2010 |
| 8818 | } |
| 8819 | } |
| 8820 | } |
| 8821 | break; |
| 8822 | } |
| 8823 | else |
| 8824 | { |
| 8825 | // If the packet TTL is zero, that means we're deleting this record. |
| 8826 | // To give other hosts on the network a chance to protest, we push the deletion |
| 8827 | // out one second into the future. Also, we set UnansweredQueries to MaxUnansweredQueries. |
| 8828 | // Otherwise, we'll do final queries for this record at 80% and 90% of its apparent |
| 8829 | // lifetime (800ms and 900ms from now) which is a pointless waste of network bandwidth. |
| 8830 | // If record's current expiry time is more than a second from now, we set it to expire in one second. |
| 8831 | // If the record is already going to expire in less than one second anyway, we leave it alone -- |
| 8832 | // we don't want to let the goodbye packet *extend* the record's lifetime in our cache. |
| 8833 | debugf("DE for %s" , CRDisplayString(m, rr)); |
| 8834 | if (RRExpireTime(rr) - m->timenow > mDNSPlatformOneSecond) |
| 8835 | { |
| 8836 | rr->resrec.rroriginalttl = 1; |
| 8837 | rr->TimeRcvd = m->timenow; |
| 8838 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 8839 | SetNextCacheCheckTimeForRecord(m, rr); |
| 8840 | } |
| 8841 | break; |
| 8842 | } |
| 8843 | } |
| 8844 | } |
| 8845 | return rr; |
| 8846 | } |
| 8847 | |
| 8848 | mDNSlocal void mDNSParseNSEC3Records(mDNS *const m, const DNSMessage *const response, const mDNSu8 *end, |
| 8849 | const mDNSInterfaceID InterfaceID, CacheRecord **NSEC3Records) |
| 8850 | { |
| 8851 | const mDNSu8 *ptr; |
| 8852 | CacheRecord *rr; |
| 8853 | int i; |
| 8854 | |
| 8855 | if (!response->h.numAuthorities) |
| 8856 | return; |
| 8857 | ptr = LocateAuthorities(response, end); |
| 8858 | if (!ptr) |
| 8859 | { |
| 8860 | LogInfo("mDNSParseNSEC3Records: ERROR can't locate authorities" ); |
| 8861 | return; |
| 8862 | } |
| 8863 | for (i = 0; i < response->h.numAuthorities && ptr && ptr < end; i++) |
| 8864 | { |
| 8865 | CacheGroup *cg; |
| 8866 | |
| 8867 | ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); |
| 8868 | if (!ptr || m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative || m->rec.r.resrec.rrtype != kDNSType_NSEC3) |
| 8869 | { |
| 8870 | debugf("mDNSParseNSEC3Records: ptr %p, Record %s, ignoring" , ptr, CRDisplayString(m, &m->rec.r)); |
| 8871 | m->rec.r.resrec.RecordType = 0; |
| 8872 | continue; |
| 8873 | } |
| 8874 | cg = CacheGroupForRecord(m, &m->rec.r.resrec); |
| 8875 | // Create the cache entry but don't add it to the cache it. We need |
| 8876 | // to cache this along with the main cache record. |
| 8877 | rr = CreateNewCacheEntry(m, HashSlotFromNameHash(m->rec.r.resrec.namehash), cg, 0, mDNSfalse, mDNSNULL); |
| 8878 | if (rr) |
| 8879 | { |
| 8880 | debugf("mDNSParseNSEC3Records: %s" , CRDisplayString(m, rr)); |
| 8881 | *NSEC3Records = rr; |
| 8882 | NSEC3Records = &rr->next; |
| 8883 | } |
| 8884 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 8885 | } |
| 8886 | } |
| 8887 | |
| 8888 | mDNSlocal void mDNSCoreResetRecord(mDNS *const m) |
| 8889 | { |
| 8890 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 8891 | if (m->rec.r.resrec.AnonInfo) |
| 8892 | { |
| 8893 | FreeAnonInfo(m->rec.r.resrec.AnonInfo); |
| 8894 | m->rec.r.resrec.AnonInfo = mDNSNULL; |
| 8895 | } |
| 8896 | } |
| 8897 | |
| 8898 | // Note: mDNSCoreReceiveResponse calls mDNS_Deregister_internal which can call a user callback, which may change |
| 8899 | // the record list and/or question list. |
| 8900 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 8901 | // InterfaceID non-NULL tells us the interface this multicast response was received on |
| 8902 | // InterfaceID NULL tells us this was a unicast response |
| 8903 | // dstaddr NULL tells us we received this over an outgoing TCP connection we made |
| 8904 | mDNSlocal void mDNSCoreReceiveResponse(mDNS *const m, |
| 8905 | const DNSMessage *const response, const mDNSu8 *end, |
| 8906 | const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, |
| 8907 | const mDNSInterfaceID InterfaceID) |
| 8908 | { |
| 8909 | int i; |
| 8910 | mDNSBool ResponseMCast = dstaddr && mDNSAddrIsDNSMulticast(dstaddr); |
| 8911 | mDNSBool ResponseSrcLocal = !srcaddr || mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr); |
| 8912 | DNSQuestion *llqMatch = mDNSNULL; |
| 8913 | DNSQuestion *unicastQuestion = mDNSNULL; |
| 8914 | uDNS_LLQType LLQType = uDNS_recvLLQResponse(m, response, end, srcaddr, srcport, &llqMatch); |
| 8915 | |
| 8916 | // "(CacheRecord*)1" is a special (non-zero) end-of-list marker |
| 8917 | // We use this non-zero marker so that records in our CacheFlushRecords list will always have NextInCFList |
| 8918 | // set non-zero, and that tells GetCacheEntity() that they're not, at this moment, eligible for recycling. |
| 8919 | CacheRecord *CacheFlushRecords = (CacheRecord*)1; |
| 8920 | CacheRecord **cfp = &CacheFlushRecords; |
| 8921 | CacheRecord *NSECRecords = mDNSNULL; |
| 8922 | CacheRecord *NSECCachePtr = mDNSNULL; |
| 8923 | CacheRecord **nsecp = &NSECRecords; |
| 8924 | CacheRecord *McastNSEC3Records = mDNSNULL; |
| 8925 | mDNSBool nseclist; |
| 8926 | mDNSu8 rcode = '\0'; |
| 8927 | mDNSBool rrsigsCreated = mDNSfalse; |
| 8928 | mDNSBool DNSSECQuestion = mDNSfalse; |
| 8929 | NetworkInterfaceInfo *llintf = FirstIPv4LLInterfaceForID(m, InterfaceID); |
| 8930 | mDNSBool recordAcceptedInResponse = mDNSfalse; // Set if a record is accepted from a unicast mDNS response that answers an existing question. |
| 8931 | |
| 8932 | // All records in a DNS response packet are treated as equally valid statements of truth. If we want |
| 8933 | // to guard against spoof responses, then the only credible protection against that is cryptographic |
| 8934 | // security, e.g. DNSSEC., not worrying about which section in the spoof packet contained the record. |
| 8935 | int firstauthority = response->h.numAnswers; |
| 8936 | int firstadditional = firstauthority + response->h.numAuthorities; |
| 8937 | int totalrecords = firstadditional + response->h.numAdditionals; |
| 8938 | const mDNSu8 *ptr = response->data; |
| 8939 | DNSServer *uDNSServer = mDNSNULL; |
| 8940 | |
| 8941 | debugf("Received Response from %#-15a addressed to %#-15a on %p with " |
| 8942 | "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes LLQType %d" , |
| 8943 | srcaddr, dstaddr, InterfaceID, |
| 8944 | response->h.numQuestions, response->h.numQuestions == 1 ? ", " : "s," , |
| 8945 | response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s," , |
| 8946 | response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies," , |
| 8947 | response->h.numAdditionals, response->h.numAdditionals == 1 ? " " : "s" , end - response->data, LLQType); |
| 8948 | |
| 8949 | #if AWD_METRICS |
| 8950 | if (mDNSSameIPPort(srcport, UnicastDNSPort)) |
| 8951 | { |
| 8952 | MetricsUpdateDNSResponseSize((mDNSu32)(end - (mDNSu8 *)response)); |
| 8953 | } |
| 8954 | #endif |
| 8955 | |
| 8956 | // According to RFC 2181 <http://www.ietf.org/rfc/rfc2181.txt> |
| 8957 | // When a DNS client receives a reply with TC |
| 8958 | // set, it should ignore that response, and query again, using a |
| 8959 | // mechanism, such as a TCP connection, that will permit larger replies. |
| 8960 | // It feels wrong to be throwing away data after the network went to all the trouble of delivering it to us, but |
| 8961 | // delivering some records of the RRSet first and then the remainder a couple of milliseconds later was causing |
| 8962 | // failures in our Microsoft Active Directory client, which expects to get the entire set of answers at once. |
| 8963 | // <rdar://problem/6690034> Can't bind to Active Directory |
| 8964 | // In addition, if the client immediately canceled its query after getting the initial partial response, then we'll |
| 8965 | // abort our TCP connection, and not complete the operation, and end up with an incomplete RRSet in our cache. |
| 8966 | // Next time there's a query for this RRSet we'll see answers in our cache, and assume we have the whole RRSet already, |
| 8967 | // and not even do the TCP query. |
| 8968 | // Accordingly, if we get a uDNS reply with kDNSFlag0_TC set, we bail out and wait for the TCP response containing the entire RRSet. |
| 8969 | if (!InterfaceID && (response->h.flags.b[0] & kDNSFlag0_TC)) return; |
| 8970 | |
| 8971 | if (LLQType == uDNS_LLQ_Ignore) return; |
| 8972 | |
| 8973 | // 1. We ignore questions (if any) in mDNS response packets |
| 8974 | // 2. If this is an LLQ response, we handle it much the same |
| 8975 | // 3. If we get a uDNS UDP response with the TC (truncated) bit set, then we can't treat this |
| 8976 | // answer as being the authoritative complete RRSet, and respond by deleting all other |
| 8977 | // matching cache records that don't appear in this packet. |
| 8978 | // Otherwise, this is a authoritative uDNS answer, so arrange for any stale records to be purged |
| 8979 | if (ResponseMCast || LLQType == uDNS_LLQ_Events || (response->h.flags.b[0] & kDNSFlag0_TC)) |
| 8980 | ptr = LocateAnswers(response, end); |
| 8981 | // Otherwise, for one-shot queries, any answers in our cache that are not also contained |
| 8982 | // in this response packet are immediately deemed to be invalid. |
| 8983 | else |
| 8984 | { |
| 8985 | mDNSBool failure, returnEarly; |
| 8986 | rcode = (mDNSu8)(response->h.flags.b[1] & kDNSFlag1_RC_Mask); |
| 8987 | failure = !(rcode == kDNSFlag1_RC_NoErr || rcode == kDNSFlag1_RC_NXDomain || rcode == kDNSFlag1_RC_NotAuth); |
| 8988 | returnEarly = mDNSfalse; |
| 8989 | // We could possibly combine this with the similar loop at the end of this function -- |
| 8990 | // instead of tagging cache records here and then rescuing them if we find them in the answer section, |
| 8991 | // we could instead use the "m->PktNum" mechanism to tag each cache record with the packet number in |
| 8992 | // which it was received (or refreshed), and then at the end if we find any cache records which |
| 8993 | // answer questions in this packet's question section, but which aren't tagged with this packet's |
| 8994 | // packet number, then we deduce they are old and delete them |
| 8995 | for (i = 0; i < response->h.numQuestions && ptr && ptr < end; i++) |
| 8996 | { |
| 8997 | DNSQuestion q, *qptr = mDNSNULL; |
| 8998 | ptr = getQuestion(response, ptr, end, InterfaceID, &q); |
| 8999 | if (ptr && (qptr = ExpectingUnicastResponseForQuestion(m, dstport, response->h.id, &q, !dstaddr))) |
| 9000 | { |
| 9001 | if (!failure) |
| 9002 | { |
| 9003 | CacheRecord *rr; |
| 9004 | // Remember the unicast question that we found, which we use to make caching |
| 9005 | // decisions later on in this function |
| 9006 | CacheGroup *cg = CacheGroupForName(m, q.qnamehash, &q.qname); |
| 9007 | if (!mDNSOpaque16IsZero(response->h.id)) |
| 9008 | { |
| 9009 | unicastQuestion = qptr; |
| 9010 | if (qptr->qDNSServer && DNSSECQuestion(qptr)) |
| 9011 | { |
| 9012 | LogInfo("mDNSCoreReceiveResponse: Setting aware for %##s (%s) on %#a" , qptr->qname.c, |
| 9013 | DNSTypeName(qptr->qtype), &qptr->qDNSServer->addr); |
| 9014 | qptr->qDNSServer->DNSSECAware = mDNStrue; |
| 9015 | qptr->qDNSServer->req_DO = mDNStrue; |
| 9016 | } |
| 9017 | if (qptr->ValidatingResponse) |
| 9018 | DNSSECQuestion = mDNStrue; |
| 9019 | } |
| 9020 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 9021 | if (SameNameRecordAnswersQuestion(&rr->resrec, qptr)) |
| 9022 | { |
| 9023 | debugf("uDNS marking %p %##s (%s) %p %s" , q.InterfaceID, q.qname.c, DNSTypeName(q.qtype), |
| 9024 | rr->resrec.InterfaceID, CRDisplayString(m, rr)); |
| 9025 | // Don't want to disturb rroriginalttl here, because code below might need it for the exponential backoff doubling algorithm |
| 9026 | rr->TimeRcvd = m->timenow - TicksTTL(rr) - 1; |
| 9027 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 9028 | rr->CRDNSSECQuestion = 0; |
| 9029 | if (unicastQuestion && DNSSECQuestion(unicastQuestion)) |
| 9030 | { |
| 9031 | LogInfo("mDNSCoreReceiveResponse: CRDNSSECQuestion set for record %s, question %##s (%s)" , CRDisplayString(m, rr), |
| 9032 | unicastQuestion->qname.c, DNSTypeName(unicastQuestion->qtype)); |
| 9033 | rr->CRDNSSECQuestion = 1; |
| 9034 | } |
| 9035 | } |
| 9036 | } |
| 9037 | else |
| 9038 | { |
| 9039 | if (qptr) |
| 9040 | { |
| 9041 | // If we recv any error from the DNSServer for a DNSSEC Query and if we know that the server |
| 9042 | // is not DNSSEC aware, stop doing DNSSEC for that DNSServer. Note that by setting the |
| 9043 | // req_DO to false here, the next retransmission for this question will turn off validation |
| 9044 | // and hence retransmit without the EDNS0/DOK option. |
| 9045 | if (DNSSECOptionalQuestion(qptr) && qptr->qDNSServer && !qptr->qDNSServer->DNSSECAware) |
| 9046 | { |
| 9047 | LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to DNSSEC Query %##s (%s), clear DO flag" , |
| 9048 | qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype)); |
| 9049 | qptr->qDNSServer->req_DO = mDNSfalse; |
| 9050 | } |
| 9051 | // For Unicast DNS Queries, penalize the DNSServer |
| 9052 | else |
| 9053 | { |
| 9054 | LogInfo("mDNSCoreReceiveResponse: Server %p responded with code %d to query %##s (%s)" , |
| 9055 | qptr->qDNSServer, rcode, q.qname.c, DNSTypeName(q.qtype)); |
| 9056 | PenalizeDNSServer(m, qptr, response->h.flags); |
| 9057 | } |
| 9058 | } |
| 9059 | returnEarly = mDNStrue; |
| 9060 | } |
| 9061 | } |
| 9062 | } |
| 9063 | if (returnEarly) |
| 9064 | { |
| 9065 | LogInfo("Ignoring %2d Answer%s %2d Authorit%s %2d Additional%s" , |
| 9066 | response->h.numAnswers, response->h.numAnswers == 1 ? ", " : "s," , |
| 9067 | response->h.numAuthorities, response->h.numAuthorities == 1 ? "y, " : "ies," , |
| 9068 | response->h.numAdditionals, response->h.numAdditionals == 1 ? "" : "s" ); |
| 9069 | // not goto exit because we won't have any CacheFlushRecords and we do not want to |
| 9070 | // generate negative cache entries (we want to query the next server) |
| 9071 | return; |
| 9072 | } |
| 9073 | if (unicastQuestion && DNSSECQuestion(unicastQuestion)) |
| 9074 | { |
| 9075 | BumpDNSSECStats(m, kStatsActionSet, kStatsTypeMsgSize, (end - response->data)); |
| 9076 | } |
| 9077 | } |
| 9078 | |
| 9079 | // Parse the NSEC3 records from the Authority section before we process |
| 9080 | // the Answer section so that we can cache them along with the proper |
| 9081 | // cache records we create. |
| 9082 | if (mDNSOpaque16IsZero(response->h.id)) |
| 9083 | mDNSParseNSEC3Records(m, response, end, InterfaceID, &McastNSEC3Records); |
| 9084 | |
| 9085 | for (i = 0; i < totalrecords && ptr && ptr < end; i++) |
| 9086 | { |
| 9087 | // All responses sent via LL multicast are acceptable for caching |
| 9088 | // All responses received over our outbound TCP connections are acceptable for caching |
| 9089 | // We accept all records in a unicast response to a multicast query once we find one that |
| 9090 | // answers an active question. |
| 9091 | mDNSBool AcceptableResponse = ResponseMCast || !dstaddr || LLQType || recordAcceptedInResponse; |
| 9092 | // (Note that just because we are willing to cache something, that doesn't necessarily make it a trustworthy answer |
| 9093 | // to any specific question -- any code reading records from the cache needs to make that determination for itself.) |
| 9094 | |
| 9095 | const mDNSu8 RecordType = |
| 9096 | (i < firstauthority ) ? (mDNSu8)kDNSRecordTypePacketAns : |
| 9097 | (i < firstadditional) ? (mDNSu8)kDNSRecordTypePacketAuth : (mDNSu8)kDNSRecordTypePacketAdd; |
| 9098 | ptr = GetLargeResourceRecord(m, response, ptr, end, InterfaceID, RecordType, &m->rec); |
| 9099 | if (!ptr) goto exit; // Break out of the loop and clean up our CacheFlushRecords list before exiting |
| 9100 | |
| 9101 | if (m->rec.r.resrec.RecordType == kDNSRecordTypePacketNegative) |
| 9102 | { |
| 9103 | mDNSCoreResetRecord(m); |
| 9104 | continue; |
| 9105 | } |
| 9106 | |
| 9107 | // We have already parsed the NSEC3 records and cached them approrpriately for |
| 9108 | // multicast responses. |
| 9109 | if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype == kDNSType_NSEC3) |
| 9110 | { |
| 9111 | mDNSCoreResetRecord(m); |
| 9112 | continue; |
| 9113 | } |
| 9114 | // Don't want to cache OPT or TSIG pseudo-RRs |
| 9115 | if (m->rec.r.resrec.rrtype == kDNSType_TSIG) |
| 9116 | { |
| 9117 | mDNSCoreResetRecord(m); |
| 9118 | continue; |
| 9119 | } |
| 9120 | if (m->rec.r.resrec.rrtype == kDNSType_OPT) |
| 9121 | { |
| 9122 | const rdataOPT *opt; |
| 9123 | const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; |
| 9124 | // Find owner sub-option(s). We verify that the MAC is non-zero, otherwise we could inadvertently |
| 9125 | // delete all our own AuthRecords (which are identified by having zero MAC tags on them). |
| 9126 | for (opt = &m->rec.r.resrec.rdata->u.opt[0]; opt < e; opt++) |
| 9127 | if (opt->opt == kDNSOpt_Owner && opt->u.owner.vers == 0 && opt->u.owner.HMAC.l[0]) |
| 9128 | { |
| 9129 | ClearProxyRecords(m, &opt->u.owner, m->DuplicateRecords); |
| 9130 | ClearProxyRecords(m, &opt->u.owner, m->ResourceRecords); |
| 9131 | } |
| 9132 | mDNSCoreResetRecord(m); |
| 9133 | continue; |
| 9134 | } |
| 9135 | // if a CNAME record points to itself, then don't add it to the cache |
| 9136 | if ((m->rec.r.resrec.rrtype == kDNSType_CNAME) && SameDomainName(m->rec.r.resrec.name, &m->rec.r.resrec.rdata->u.name)) |
| 9137 | { |
| 9138 | LogInfo("mDNSCoreReceiveResponse: CNAME loop domain name %##s" , m->rec.r.resrec.name->c); |
| 9139 | mDNSCoreResetRecord(m); |
| 9140 | continue; |
| 9141 | } |
| 9142 | |
| 9143 | // When we receive uDNS LLQ responses, we assume a long cache lifetime -- |
| 9144 | // In the case of active LLQs, we'll get remove events when the records actually do go away |
| 9145 | // In the case of polling LLQs, we assume the record remains valid until the next poll |
| 9146 | if (!mDNSOpaque16IsZero(response->h.id)) |
| 9147 | m->rec.r.resrec.rroriginalttl = GetEffectiveTTL(LLQType, m->rec.r.resrec.rroriginalttl); |
| 9148 | |
| 9149 | // If response was not sent via LL multicast, |
| 9150 | // then see if it answers a recent query of ours, which would also make it acceptable for caching. |
| 9151 | if (!ResponseMCast) |
| 9152 | { |
| 9153 | if (LLQType) |
| 9154 | { |
| 9155 | // For Long Lived queries that are both sent over UDP and Private TCP, LLQType is set. |
| 9156 | // Even though it is AcceptableResponse, we need a matching DNSServer pointer for the |
| 9157 | // queries to get ADD/RMV events. To lookup the question, we can't use |
| 9158 | // ExpectingUnicastResponseForRecord as the port numbers don't match. uDNS_recvLLQRespose |
| 9159 | // has already matched the question using the 64 bit Id in the packet and we use that here. |
| 9160 | |
| 9161 | if (llqMatch != mDNSNULL) m->rec.r.resrec.rDNSServer = uDNSServer = llqMatch->qDNSServer; |
| 9162 | |
| 9163 | // If this is a DNSSEC question that is also LongLived, don't accept records from the |
| 9164 | // Additional/Authority section blindly. We need to go through IsAcceptableResponse below |
| 9165 | // so that NSEC/NSEC3 record are cached in the nseclist if we accept them. This can happen |
| 9166 | // for both negative responses and wildcard expanded positive responses as both of come |
| 9167 | // back with NSEC/NSEC3s. |
| 9168 | if (unicastQuestion && DNSSECQuestion(unicastQuestion)) |
| 9169 | AcceptableResponse = mDNSfalse; |
| 9170 | } |
| 9171 | else if (!AcceptableResponse || !dstaddr) |
| 9172 | { |
| 9173 | // For responses that come over TCP (Responses that can't fit within UDP) or TLS (Private queries |
| 9174 | // that are not long lived e.g., AAAA lookup in a Private domain), it is indicated by !dstaddr. |
| 9175 | // Even though it is AcceptableResponse, we still need a DNSServer pointer for the resource records that |
| 9176 | // we create. |
| 9177 | |
| 9178 | DNSQuestion *q = ExpectingUnicastResponseForRecord(m, srcaddr, ResponseSrcLocal, dstport, response->h.id, &m->rec.r, !dstaddr); |
| 9179 | |
| 9180 | // Initialize the DNS server on the resource record which will now filter what questions we answer with |
| 9181 | // this record. |
| 9182 | // |
| 9183 | // We could potentially lookup the DNS server based on the source address, but that may not work always |
| 9184 | // and that's why ExpectingUnicastResponseForRecord does not try to verify whether the response came |
| 9185 | // from the DNS server that queried. We follow the same logic here. If we can find a matching quetion based |
| 9186 | // on the "id" and "source port", then this response answers the question and assume the response |
| 9187 | // came from the same DNS server that we sent the query to. |
| 9188 | |
| 9189 | if (q != mDNSNULL) |
| 9190 | { |
| 9191 | AcceptableResponse = mDNStrue; |
| 9192 | if (!InterfaceID) |
| 9193 | { |
| 9194 | debugf("mDNSCoreReceiveResponse: InterfaceID %p %##s (%s)" , q->InterfaceID, q->qname.c, DNSTypeName(q->qtype)); |
| 9195 | m->rec.r.resrec.rDNSServer = uDNSServer = q->qDNSServer; |
| 9196 | } |
| 9197 | else |
| 9198 | { |
| 9199 | // Accept all remaining records in this unicast response to an mDNS query. |
| 9200 | recordAcceptedInResponse = mDNStrue; |
| 9201 | LogInfo("mDNSCoreReceiveResponse: Accepting response for query: %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 9202 | } |
| 9203 | } |
| 9204 | else |
| 9205 | { |
| 9206 | // If we can't find a matching question, we need to see whether we have seen records earlier that matched |
| 9207 | // the question. The code below does that. So, make this record unacceptable for now |
| 9208 | if (!InterfaceID) |
| 9209 | { |
| 9210 | debugf("mDNSCoreReceiveResponse: Can't find question for record name %##s" , m->rec.r.resrec.name->c); |
| 9211 | AcceptableResponse = mDNSfalse; |
| 9212 | } |
| 9213 | } |
| 9214 | } |
| 9215 | } |
| 9216 | else if (llintf && llintf->IgnoreIPv4LL && m->rec.r.resrec.rrtype == kDNSType_A) |
| 9217 | { |
| 9218 | // There are some routers (rare, thankfully) that generate bogus ARP responses for |
| 9219 | // any IPv4 address they don’t recognize, including RFC 3927 IPv4 link-local addresses. |
| 9220 | // To work with these broken routers, client devices need to blacklist these broken |
| 9221 | // routers and ignore their bogus ARP responses. Some devices implement a technique |
| 9222 | // such as the one described in US Patent 7436783, which lets clients detect and |
| 9223 | // ignore these broken routers: <https://www.google.com/patents/US7436783> |
| 9224 | |
| 9225 | // OS X and iOS do not implement this defensive mechanism, instead taking a simpler |
| 9226 | // approach of just detecting these broken routers and completely disabling IPv4 |
| 9227 | // link-local communication on interfaces where a broken router is detected. |
| 9228 | // OS X and iOS set the IFEF_ARPLL interface flag on interfaces |
| 9229 | // that are deemed “safe” for IPv4 link-local communication; |
| 9230 | // the flag is cleared on interfaces where a broken router is detected. |
| 9231 | |
| 9232 | // OS X and iOS will not even try to communicate with an IPv4 |
| 9233 | // link-local destination on an interface without the IFEF_ARPLL flag set. |
| 9234 | // This can cause some badly written applications to freeze for a long time if they |
| 9235 | // attempt to connect to an IPv4 link-local destination address and then wait for |
| 9236 | // that connection attempt to time out before trying other candidate addresses. |
| 9237 | |
| 9238 | // To mask this client bug, we suppress acceptance of IPv4 link-local address |
| 9239 | // records on interfaces where we know the OS will be unwilling even to attempt |
| 9240 | // communication with those IPv4 link-local destination addresses. |
| 9241 | // <rdar://problem/9400639> kSuppress IPv4LL answers on interfaces without IFEF_ARPLL |
| 9242 | |
| 9243 | const CacheRecord *const rr = &m->rec.r; |
| 9244 | const RDataBody2 *const rdb = (RDataBody2 *)rr->smallrdatastorage.data; |
| 9245 | if (mDNSv4AddressIsLinkLocal(&rdb->ipv4)) |
| 9246 | { |
| 9247 | LogInfo("mDNSResponder: Dropping LinkLocal packet %s" , CRDisplayString(m, &m->rec.r)); |
| 9248 | mDNSCoreResetRecord(m); |
| 9249 | continue; |
| 9250 | } |
| 9251 | } |
| 9252 | |
| 9253 | // 1. Check that this packet resource record does not conflict with any of ours |
| 9254 | if (mDNSOpaque16IsZero(response->h.id) && m->rec.r.resrec.rrtype != kDNSType_NSEC) |
| 9255 | { |
| 9256 | if (m->CurrentRecord) |
| 9257 | LogMsg("mDNSCoreReceiveResponse ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 9258 | m->CurrentRecord = m->ResourceRecords; |
| 9259 | while (m->CurrentRecord) |
| 9260 | { |
| 9261 | AuthRecord *rr = m->CurrentRecord; |
| 9262 | m->CurrentRecord = rr->next; |
| 9263 | // We accept all multicast responses, and unicast responses resulting from queries we issued |
| 9264 | // For other unicast responses, this code accepts them only for responses with an |
| 9265 | // (apparently) local source address that pertain to a record of our own that's in probing state |
| 9266 | if (!AcceptableResponse && !(ResponseSrcLocal && rr->resrec.RecordType == kDNSRecordTypeUnique)) continue; |
| 9267 | |
| 9268 | if (PacketRRMatchesSignature(&m->rec.r, rr)) // If interface, name, type (if shared record) and class match... |
| 9269 | { |
| 9270 | // ... check to see if type and rdata are identical |
| 9271 | if (IdenticalSameNameRecord(&m->rec.r.resrec, &rr->resrec)) |
| 9272 | { |
| 9273 | // If the RR in the packet is identical to ours, just check they're not trying to lower the TTL on us |
| 9274 | if (m->rec.r.resrec.rroriginalttl >= rr->resrec.rroriginalttl/2 || m->SleepState) |
| 9275 | { |
| 9276 | // If we were planning to send on this -- and only this -- interface, then we don't need to any more |
| 9277 | if (rr->ImmedAnswer == InterfaceID) { rr->ImmedAnswer = mDNSNULL; rr->ImmedUnicast = mDNSfalse; } |
| 9278 | } |
| 9279 | else |
| 9280 | { |
| 9281 | if (rr->ImmedAnswer == mDNSNULL) { rr->ImmedAnswer = InterfaceID; m->NextScheduledResponse = m->timenow; } |
| 9282 | else if (rr->ImmedAnswer != InterfaceID) { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; } |
| 9283 | } |
| 9284 | } |
| 9285 | // else, the packet RR has different type or different rdata -- check to see if this is a conflict |
| 9286 | else if (m->rec.r.resrec.rroriginalttl > 0 && PacketRRConflict(m, rr, &m->rec.r)) |
| 9287 | { |
| 9288 | LogInfo("mDNSCoreReceiveResponse: Pkt Record: %08lX %s" , m->rec.r.resrec.rdatahash, CRDisplayString(m, &m->rec.r)); |
| 9289 | LogInfo("mDNSCoreReceiveResponse: Our Record: %08lX %s" , rr->resrec.rdatahash, ARDisplayString(m, rr)); |
| 9290 | |
| 9291 | // If this record is marked DependentOn another record for conflict detection purposes, |
| 9292 | // then *that* record has to be bumped back to probing state to resolve the conflict |
| 9293 | if (rr->DependentOn) |
| 9294 | { |
| 9295 | while (rr->DependentOn) rr = rr->DependentOn; |
| 9296 | LogInfo("mDNSCoreReceiveResponse: Dep Record: %08lX %s" , rr->resrec.rdatahash, ARDisplayString(m, rr)); |
| 9297 | } |
| 9298 | |
| 9299 | // If we've just whacked this record's ProbeCount, don't need to do it again |
| 9300 | if (rr->ProbeCount > DefaultProbeCountForTypeUnique) |
| 9301 | LogInfo("mDNSCoreReceiveResponse: Already reset to Probing: %s" , ARDisplayString(m, rr)); |
| 9302 | else if (rr->ProbeCount == DefaultProbeCountForTypeUnique) |
| 9303 | LogInfo("mDNSCoreReceiveResponse: Ignoring response received before we even began probing: %s" , ARDisplayString(m, rr)); |
| 9304 | else |
| 9305 | { |
| 9306 | LogMsg("mDNSCoreReceiveResponse: Received from %#a:%d %s" , srcaddr, mDNSVal16(srcport), CRDisplayString(m, &m->rec.r)); |
| 9307 | // If we'd previously verified this record, put it back to probing state and try again |
| 9308 | if (rr->resrec.RecordType == kDNSRecordTypeVerified) |
| 9309 | { |
| 9310 | LogMsg("mDNSCoreReceiveResponse: Resetting to Probing: %s" , ARDisplayString(m, rr)); |
| 9311 | rr->resrec.RecordType = kDNSRecordTypeUnique; |
| 9312 | // We set ProbeCount to one more than the usual value so we know we've already touched this record. |
| 9313 | // This is because our single probe for "example-name.local" could yield a response with (say) two A records and |
| 9314 | // three AAAA records in it, and we don't want to call RecordProbeFailure() five times and count that as five conflicts. |
| 9315 | // This special value is recognised and reset to DefaultProbeCountForTypeUnique in SendQueries(). |
| 9316 | rr->ProbeCount = DefaultProbeCountForTypeUnique + 1; |
| 9317 | rr->AnnounceCount = InitialAnnounceCount; |
| 9318 | InitializeLastAPTime(m, rr); |
| 9319 | RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate |
| 9320 | } |
| 9321 | // If we're probing for this record, we just failed |
| 9322 | else if (rr->resrec.RecordType == kDNSRecordTypeUnique) |
| 9323 | { |
| 9324 | // At this point in the code, we're probing for uniqueness. |
| 9325 | // We've sent at least one probe (rr->ProbeCount < DefaultProbeCountForTypeUnique) |
| 9326 | // but we haven't completed probing yet (rr->resrec.RecordType == kDNSRecordTypeUnique). |
| 9327 | // Before we call deregister, check if this is a packet we registered with the sleep proxy. |
| 9328 | if (!mDNSCoreRegisteredProxyRecord(m, rr)) |
| 9329 | { |
| 9330 | // This may be a conflict due to stale packets on the network. Delay probing by a second. |
| 9331 | // If there are conflicts after 3 such attempts, then it is a true conflict. |
| 9332 | if (m->DelayConflictProcessing) |
| 9333 | { |
| 9334 | m->DelayConflictProcessing--; |
| 9335 | LogMsg("Possible spurious conflict for %s. Attempt %d at suppressing probes for one second" , |
| 9336 | ARDisplayString(m, rr), (MAX_CONFLICT_PROCESSING_DELAYS - m->DelayConflictProcessing)); |
| 9337 | rr->ProbeCount = DefaultProbeCountForTypeUnique + 1; |
| 9338 | rr->AnnounceCount = InitialAnnounceCount; |
| 9339 | m->SuppressProbes = NonZeroTime(m->timenow + mDNSPlatformOneSecond); |
| 9340 | InitializeLastAPTime(m, rr); |
| 9341 | RecordProbeFailure(m, rr); // Repeated late conflicts also cause us to back off to the slower probing rate |
| 9342 | } |
| 9343 | else |
| 9344 | { |
| 9345 | LogMsg("mDNSCoreReceiveResponse: ProbeCount %d; will deregister %s" , rr->ProbeCount, ARDisplayString(m, rr)); |
| 9346 | m->mDNSStats.NameConflicts++; |
| 9347 | #if APPLE_OSX_mDNSResponder |
| 9348 | // See if this record was also registered with any D2D plugins. |
| 9349 | D2D_stop_advertising_record(rr); |
| 9350 | #endif |
| 9351 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); |
| 9352 | } |
| 9353 | |
| 9354 | } |
| 9355 | } |
| 9356 | // We assumed this record must be unique, but we were wrong. (e.g. There are two mDNSResponders on the |
| 9357 | // same machine giving different answers for the reverse mapping record, or there are two machines on the |
| 9358 | // network using the same IP address.) This is simply a misconfiguration, and there's nothing we can do |
| 9359 | // to fix it -- e.g. it's not our job to be trying to change the machine's IP address. We just discard our |
| 9360 | // record to avoid continued conflicts (as we do for a conflict on our Unique records) and get on with life. |
| 9361 | else if (rr->resrec.RecordType == kDNSRecordTypeKnownUnique) |
| 9362 | { |
| 9363 | LogMsg("mDNSCoreReceiveResponse: Unexpected conflict discarding %s" , ARDisplayString(m, rr)); |
| 9364 | m->mDNSStats.KnownUniqueNameConflicts++; |
| 9365 | #if APPLE_OSX_mDNSResponder |
| 9366 | D2D_stop_advertising_record(rr); |
| 9367 | #endif |
| 9368 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_conflict); |
| 9369 | } |
| 9370 | else |
| 9371 | LogMsg("mDNSCoreReceiveResponse: Unexpected record type %X %s" , rr->resrec.RecordType, ARDisplayString(m, rr)); |
| 9372 | } |
| 9373 | } |
| 9374 | // Else, matching signature, different type or rdata, but not a considered a conflict. |
| 9375 | // If the packet record has the cache-flush bit set, then we check to see if we |
| 9376 | // have any record(s) of the same type that we should re-assert to rescue them |
| 9377 | // (see note about "multi-homing and bridged networks" at the end of this function). |
| 9378 | else if (m->rec.r.resrec.rrtype == rr->resrec.rrtype) |
| 9379 | if ((m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (mDNSu32)(m->timenow - rr->LastMCTime) > (mDNSu32)mDNSPlatformOneSecond/2) |
| 9380 | { rr->ImmedAnswer = mDNSInterfaceMark; m->NextScheduledResponse = m->timenow; } |
| 9381 | } |
| 9382 | } |
| 9383 | } |
| 9384 | |
| 9385 | nseclist = mDNSfalse; |
| 9386 | if (!AcceptableResponse) |
| 9387 | { |
| 9388 | AcceptableResponse = IsResponseAcceptable(m, CacheFlushRecords, unicastQuestion, &nseclist); |
| 9389 | if (AcceptableResponse) m->rec.r.resrec.rDNSServer = uDNSServer; |
| 9390 | } |
| 9391 | |
| 9392 | // 2. See if we want to add this packet resource record to our cache |
| 9393 | // We only try to cache answers if we have a cache to put them in |
| 9394 | // Also, we ignore any apparent attempts at cache poisoning unicast to us that do not answer any outstanding active query |
| 9395 | if (!AcceptableResponse) LogInfo("mDNSCoreReceiveResponse ignoring %s" , CRDisplayString(m, &m->rec.r)); |
| 9396 | if (m->rrcache_size && AcceptableResponse) |
| 9397 | { |
| 9398 | const mDNSu32 slot = HashSlotFromNameHash(m->rec.r.resrec.namehash); |
| 9399 | CacheGroup *cg = CacheGroupForRecord(m, &m->rec.r.resrec); |
| 9400 | CacheRecord *rr = mDNSNULL; |
| 9401 | |
| 9402 | if (McastNSEC3Records) |
| 9403 | InitializeAnonInfoForCR(m, &McastNSEC3Records, &m->rec.r); |
| 9404 | |
| 9405 | // 2a. Check if this packet resource record is already in our cache. |
| 9406 | // |
| 9407 | // If this record should go in the nseclist, don't look in the cache for updating it. |
| 9408 | // They are supposed to be cached under the "nsec" field of the cache record for |
| 9409 | // validation. Just create the cache record. |
| 9410 | if (!nseclist) |
| 9411 | { |
| 9412 | rr = mDNSCoreReceiveCacheCheck(m, response, LLQType, slot, cg, unicastQuestion, &cfp, &NSECCachePtr, InterfaceID); |
| 9413 | } |
| 9414 | |
| 9415 | // If packet resource record not in our cache, add it now |
| 9416 | // (unless it is just a deletion of a record we never had, in which case we don't care) |
| 9417 | if (!rr && m->rec.r.resrec.rroriginalttl > 0) |
| 9418 | { |
| 9419 | const mDNSBool AddToCFList = (m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask) && (LLQType != uDNS_LLQ_Events); |
| 9420 | mDNSs32 delay; |
| 9421 | |
| 9422 | if (AddToCFList) |
| 9423 | delay = NonZeroTime(m->timenow + mDNSPlatformOneSecond); |
| 9424 | else |
| 9425 | delay = CheckForSoonToExpireRecords(m, m->rec.r.resrec.name, m->rec.r.resrec.namehash, mDNSNULL); |
| 9426 | |
| 9427 | // If unique, assume we may have to delay delivery of this 'add' event. |
| 9428 | // Below, where we walk the CacheFlushRecords list, we either call CacheRecordDeferredAdd() |
| 9429 | // to immediately to generate answer callbacks, or we call ScheduleNextCacheCheckTime() |
| 9430 | // to schedule an mDNS_Execute task at the appropriate time. |
| 9431 | rr = CreateNewCacheEntry(m, slot, cg, delay, !nseclist, srcaddr); |
| 9432 | if (rr) |
| 9433 | { |
| 9434 | rr->responseFlags = response->h.flags; |
| 9435 | // If we are not creating signatures, then we need to inform DNSSEC so that |
| 9436 | // it does not wait forever. Don't do this if we got NSEC records |
| 9437 | // as it indicates that this name does not exist. |
| 9438 | if (rr->resrec.rrtype == kDNSType_RRSIG && !nseclist) |
| 9439 | { |
| 9440 | rrsigsCreated = mDNStrue; |
| 9441 | } |
| 9442 | // Remember whether we created a cache record in response to a DNSSEC question. |
| 9443 | // This helps DNSSEC code not to reissue the question to fetch the DNSSEC records. |
| 9444 | rr->CRDNSSECQuestion = 0; |
| 9445 | if (unicastQuestion && DNSSECQuestion(unicastQuestion)) |
| 9446 | { |
| 9447 | LogInfo("mDNSCoreReceiveResponse: CRDNSSECQuestion set for new record %s, question %##s (%s)" , CRDisplayString(m, rr), |
| 9448 | unicastQuestion->qname.c, DNSTypeName(unicastQuestion->qtype)); |
| 9449 | rr->CRDNSSECQuestion = 1; |
| 9450 | } |
| 9451 | // NSEC/NSEC3 records and its signatures are cached with the negative cache entry |
| 9452 | // which we should be creating below. It is also needed in the wildcard |
| 9453 | // expanded answer case and in that case it is cached along with the answer. |
| 9454 | if (nseclist) |
| 9455 | { |
| 9456 | rr->TimeRcvd = m->timenow; |
| 9457 | *nsecp = rr; |
| 9458 | nsecp = &rr->next; |
| 9459 | } |
| 9460 | else if (AddToCFList) |
| 9461 | { |
| 9462 | *cfp = rr; |
| 9463 | cfp = &rr->NextInCFList; |
| 9464 | *cfp = (CacheRecord*)1; |
| 9465 | } |
| 9466 | else if (rr->DelayDelivery) |
| 9467 | { |
| 9468 | ScheduleNextCacheCheckTime(m, slot, rr->DelayDelivery); |
| 9469 | } |
| 9470 | } |
| 9471 | } |
| 9472 | else |
| 9473 | { |
| 9474 | if (rr && rr->resrec.AnonInfo && m->rec.r.resrec.AnonInfo) |
| 9475 | { |
| 9476 | CopyAnonInfoForCR(m, rr, &m->rec.r); |
| 9477 | } |
| 9478 | } |
| 9479 | } |
| 9480 | mDNSCoreResetRecord(m); |
| 9481 | } |
| 9482 | |
| 9483 | exit: |
| 9484 | mDNSCoreResetRecord(m); |
| 9485 | |
| 9486 | // If we've just received one or more records with their cache flush bits set, |
| 9487 | // then scan that cache slot to see if there are any old stale records we need to flush |
| 9488 | while (CacheFlushRecords != (CacheRecord*)1) |
| 9489 | { |
| 9490 | CacheRecord *r1 = CacheFlushRecords, *r2; |
| 9491 | const mDNSu32 slot = HashSlotFromNameHash(r1->resrec.namehash); |
| 9492 | const CacheGroup *cg = CacheGroupForRecord(m, &r1->resrec); |
| 9493 | CacheFlushRecords = CacheFlushRecords->NextInCFList; |
| 9494 | r1->NextInCFList = mDNSNULL; |
| 9495 | |
| 9496 | // Look for records in the cache with the same signature as this new one with the cache flush |
| 9497 | // bit set, and either (a) if they're fresh, just make sure the whole RRSet has the same TTL |
| 9498 | // (as required by DNS semantics) or (b) if they're old, mark them for deletion in one second. |
| 9499 | // We make these TTL adjustments *only* for records that still have *more* than one second |
| 9500 | // remaining to live. Otherwise, a record that we tagged for deletion half a second ago |
| 9501 | // (and now has half a second remaining) could inadvertently get its life extended, by either |
| 9502 | // (a) if we got an explicit goodbye packet half a second ago, the record would be considered |
| 9503 | // "fresh" and would be incorrectly resurrected back to the same TTL as the rest of the RRSet, |
| 9504 | // or (b) otherwise, the record would not be fully resurrected, but would be reset to expire |
| 9505 | // in one second, thereby inadvertently delaying its actual expiration, instead of hastening it. |
| 9506 | // If this were to happen repeatedly, the record's expiration could be deferred indefinitely. |
| 9507 | // To avoid this, we need to ensure that the cache flushing operation will only act to |
| 9508 | // *decrease* a record's remaining lifetime, never *increase* it. |
| 9509 | for (r2 = cg ? cg->members : mDNSNULL; r2; r2=r2->next) |
| 9510 | { |
| 9511 | mDNSu16 id1; |
| 9512 | mDNSu16 id2; |
| 9513 | if (!r1->resrec.InterfaceID) |
| 9514 | { |
| 9515 | id1 = (r1->resrec.rDNSServer ? r1->resrec.rDNSServer->resGroupID : 0); |
| 9516 | id2 = (r2->resrec.rDNSServer ? r2->resrec.rDNSServer->resGroupID : 0); |
| 9517 | } |
| 9518 | else |
| 9519 | { |
| 9520 | id1 = id2 = 0; |
| 9521 | } |
| 9522 | // When we receive new RRSIGs e.g., for DNSKEY record, we should not flush the old |
| 9523 | // RRSIGS e.g., for TXT record. To do so, we need to look at the typeCovered field of |
| 9524 | // the new RRSIG that we received. Process only if the typeCovered matches. |
| 9525 | if ((r1->resrec.rrtype == r2->resrec.rrtype) && (r1->resrec.rrtype == kDNSType_RRSIG)) |
| 9526 | { |
| 9527 | rdataRRSig *rrsig1 = (rdataRRSig *)(((RDataBody2 *)(r1->resrec.rdata->u.data))->data); |
| 9528 | rdataRRSig *rrsig2 = (rdataRRSig *)(((RDataBody2 *)(r2->resrec.rdata->u.data))->data); |
| 9529 | if (swap16(rrsig1->typeCovered) != swap16(rrsig2->typeCovered)) |
| 9530 | { |
| 9531 | debugf("mDNSCoreReceiveResponse: Received RRSIG typeCovered %s, found %s, not processing" , |
| 9532 | DNSTypeName(swap16(rrsig1->typeCovered)), DNSTypeName(swap16(rrsig2->typeCovered))); |
| 9533 | continue; |
| 9534 | } |
| 9535 | } |
| 9536 | |
| 9537 | // For Unicast (null InterfaceID) the resolver IDs should also match |
| 9538 | if ((r1->resrec.InterfaceID == r2->resrec.InterfaceID) && |
| 9539 | (r1->resrec.InterfaceID || (id1 == id2)) && |
| 9540 | r1->resrec.rrtype == r2->resrec.rrtype && |
| 9541 | r1->resrec.rrclass == r2->resrec.rrclass) |
| 9542 | { |
| 9543 | // If record is recent, just ensure the whole RRSet has the same TTL (as required by DNS semantics) |
| 9544 | // else, if record is old, mark it to be flushed |
| 9545 | if (m->timenow - r2->TimeRcvd < mDNSPlatformOneSecond && RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond) |
| 9546 | { |
| 9547 | // If we find mismatched TTLs in an RRSet, correct them. |
| 9548 | // We only do this for records with a TTL of 2 or higher. It's possible to have a |
| 9549 | // goodbye announcement with the cache flush bit set (or a case-change on record rdata, |
| 9550 | // which we treat as a goodbye followed by an addition) and in that case it would be |
| 9551 | // inappropriate to synchronize all the other records to a TTL of 0 (or 1). |
| 9552 | |
| 9553 | // We suppress the message for the specific case of correcting from 240 to 60 for type TXT, |
| 9554 | // because certain early Bonjour devices are known to have this specific mismatch, and |
| 9555 | // there's no point filling syslog with messages about something we already know about. |
| 9556 | // We also don't log this for uDNS responses, since a caching name server is obliged |
| 9557 | // to give us an aged TTL to correct for how long it has held the record, |
| 9558 | // so our received TTLs are expected to vary in that case |
| 9559 | |
| 9560 | // We also suppress log message in the case of SRV records that are received |
| 9561 | // with a TTL of 4500 that are already cached with a TTL of 120 seconds, since |
| 9562 | // this behavior was observed for a number of discoveryd based AppleTV's in iOS 8 |
| 9563 | // GM builds. |
| 9564 | if (r2->resrec.rroriginalttl != r1->resrec.rroriginalttl && r1->resrec.rroriginalttl > 1) |
| 9565 | { |
| 9566 | if (!(r2->resrec.rroriginalttl == 240 && r1->resrec.rroriginalttl == 60 && r2->resrec.rrtype == kDNSType_TXT) && |
| 9567 | !(r2->resrec.rroriginalttl == 120 && r1->resrec.rroriginalttl == 4500 && r2->resrec.rrtype == kDNSType_SRV) && |
| 9568 | mDNSOpaque16IsZero(response->h.id)) |
| 9569 | LogInfo("Correcting TTL from %4d to %4d for %s" , |
| 9570 | r2->resrec.rroriginalttl, r1->resrec.rroriginalttl, CRDisplayString(m, r2)); |
| 9571 | r2->resrec.rroriginalttl = r1->resrec.rroriginalttl; |
| 9572 | } |
| 9573 | r2->TimeRcvd = m->timenow; |
| 9574 | } |
| 9575 | else // else, if record is old, mark it to be flushed |
| 9576 | { |
| 9577 | verbosedebugf("Cache flush new %p age %d expire in %d %s" , r1, m->timenow - r1->TimeRcvd, RRExpireTime(r1) - m->timenow, CRDisplayString(m, r1)); |
| 9578 | verbosedebugf("Cache flush old %p age %d expire in %d %s" , r2, m->timenow - r2->TimeRcvd, RRExpireTime(r2) - m->timenow, CRDisplayString(m, r2)); |
| 9579 | // We set stale records to expire in one second. |
| 9580 | // This gives the owner a chance to rescue it if necessary. |
| 9581 | // This is important in the case of multi-homing and bridged networks: |
| 9582 | // Suppose host X is on Ethernet. X then connects to an AirPort base station, which happens to be |
| 9583 | // bridged onto the same Ethernet. When X announces its AirPort IP address with the cache-flush bit |
| 9584 | // set, the AirPort packet will be bridged onto the Ethernet, and all other hosts on the Ethernet |
| 9585 | // will promptly delete their cached copies of the (still valid) Ethernet IP address record. |
| 9586 | // By delaying the deletion by one second, we give X a change to notice that this bridging has |
| 9587 | // happened, and re-announce its Ethernet IP address to rescue it from deletion from all our caches. |
| 9588 | |
| 9589 | // We set UnansweredQueries to MaxUnansweredQueries to avoid expensive and unnecessary |
| 9590 | // final expiration queries for this record. |
| 9591 | |
| 9592 | // If a record is deleted twice, first with an explicit DE record, then a second time by virtue of the cache |
| 9593 | // flush bit on the new record replacing it, then we allow the record to be deleted immediately, without the usual |
| 9594 | // one-second grace period. This improves responsiveness for mDNS_Update(), as used for things like iChat status updates. |
| 9595 | // <rdar://problem/5636422> Updating TXT records is too slow |
| 9596 | // We check for "rroriginalttl == 1" because we want to include records tagged by the "packet TTL is zero" check above, |
| 9597 | // which sets rroriginalttl to 1, but not records tagged by the rdata case-change check, which sets rroriginalttl to 0. |
| 9598 | if (r2->TimeRcvd == m->timenow && r2->resrec.rroriginalttl == 1 && r2->UnansweredQueries == MaxUnansweredQueries) |
| 9599 | { |
| 9600 | LogInfo("Cache flush for DE record %s" , CRDisplayString(m, r2)); |
| 9601 | r2->resrec.rroriginalttl = 0; |
| 9602 | } |
| 9603 | else if (RRExpireTime(r2) - m->timenow > mDNSPlatformOneSecond) |
| 9604 | { |
| 9605 | // We only set a record to expire in one second if it currently has *more* than a second to live |
| 9606 | // If it's already due to expire in a second or less, we just leave it alone |
| 9607 | r2->resrec.rroriginalttl = 1; |
| 9608 | r2->UnansweredQueries = MaxUnansweredQueries; |
| 9609 | r2->TimeRcvd = m->timenow - 1; |
| 9610 | // We use (m->timenow - 1) instead of m->timenow, because we use that to identify records |
| 9611 | // that we marked for deletion via an explicit DE record |
| 9612 | } |
| 9613 | } |
| 9614 | SetNextCacheCheckTimeForRecord(m, r2); |
| 9615 | } |
| 9616 | } |
| 9617 | |
| 9618 | if (r1->DelayDelivery) // If we were planning to delay delivery of this record, see if we still need to |
| 9619 | { |
| 9620 | // If we had a unicast question for this response with at least one positive answer and we |
| 9621 | // have NSECRecords, it is most likely a wildcard expanded answer. Cache the NSEC and its |
| 9622 | // signatures along with the cache record which will be used for validation later. If |
| 9623 | // we rescued a few records earlier in this function, then NSECCachePtr would be set. In that |
| 9624 | // use that instead. |
| 9625 | if (response->h.numAnswers && unicastQuestion && NSECRecords) |
| 9626 | { |
| 9627 | if (!NSECCachePtr) |
| 9628 | { |
| 9629 | LogInfo("mDNSCoreReceiveResponse: Updating NSECCachePtr to %s" , CRDisplayString(m, r1)); |
| 9630 | NSECCachePtr = r1; |
| 9631 | } |
| 9632 | // Note: We need to do this before we call CacheRecordDeferredAdd as this |
| 9633 | // might start the verification process which needs these NSEC records |
| 9634 | if (!AddNSECSForCacheRecord(m, NSECRecords, NSECCachePtr, rcode)) |
| 9635 | { |
| 9636 | LogInfo("mDNSCoreReceiveResponse: AddNSECSForCacheRecord failed to add NSEC for %s" , CRDisplayString(m, NSECCachePtr)); |
| 9637 | FreeNSECRecords(m, NSECRecords); |
| 9638 | } |
| 9639 | NSECRecords = mDNSNULL; |
| 9640 | NSECCachePtr = mDNSNULL; |
| 9641 | } |
| 9642 | r1->DelayDelivery = CheckForSoonToExpireRecords(m, r1->resrec.name, r1->resrec.namehash, mDNSNULL); |
| 9643 | // If no longer delaying, deliver answer now, else schedule delivery for the appropriate time |
| 9644 | if (!r1->DelayDelivery) CacheRecordDeferredAdd(m, r1); |
| 9645 | else ScheduleNextCacheCheckTime(m, slot, r1->DelayDelivery); |
| 9646 | } |
| 9647 | } |
| 9648 | |
| 9649 | // If we have not consumed the NSEC records yet e.g., just refreshing the cache, |
| 9650 | // update them now for future validations. |
| 9651 | if (NSECRecords && NSECCachePtr) |
| 9652 | { |
| 9653 | LogInfo("mDNSCoreReceieveResponse: Updating NSEC records in %s" , CRDisplayString(m, NSECCachePtr)); |
| 9654 | if (!AddNSECSForCacheRecord(m, NSECRecords, NSECCachePtr, rcode)) |
| 9655 | { |
| 9656 | LogInfo("mDNSCoreReceiveResponse: AddNSECSForCacheRecord failed to add NSEC for %s" , CRDisplayString(m, NSECCachePtr)); |
| 9657 | FreeNSECRecords(m, NSECRecords); |
| 9658 | } |
| 9659 | NSECRecords = mDNSNULL; |
| 9660 | NSECCachePtr = mDNSNULL; |
| 9661 | } |
| 9662 | |
| 9663 | // If there is at least one answer and we did not create RRSIGs and there was a |
| 9664 | // ValidatingResponse question waiting for this response, give a hint that no RRSIGs |
| 9665 | // were created. We don't need to give a hint: |
| 9666 | // |
| 9667 | // - if we have no answers, the mDNSCoreReceiveNoUnicastAnswers below should |
| 9668 | // generate a negative response |
| 9669 | // |
| 9670 | // - if we have NSECRecords, it means we might have a potential proof for |
| 9671 | // non-existence of name that we are looking for |
| 9672 | // |
| 9673 | if (response->h.numAnswers && !rrsigsCreated && DNSSECQuestion && !NSECRecords) |
| 9674 | mDNSCoreReceiveNoDNSSECAnswers(m, response, end, dstaddr, dstport, InterfaceID); |
| 9675 | |
| 9676 | // See if we need to generate negative cache entries for unanswered unicast questions |
| 9677 | mDNSCoreReceiveNoUnicastAnswers(m, response, end, dstaddr, dstport, InterfaceID, LLQType, rcode, NSECRecords); |
| 9678 | |
| 9679 | if (McastNSEC3Records) |
| 9680 | { |
| 9681 | debugf("mDNSCoreReceiveResponse: McastNSEC3Records not used" ); |
| 9682 | FreeNSECRecords(m, McastNSEC3Records); |
| 9683 | } |
| 9684 | } |
| 9685 | |
| 9686 | // ScheduleWakeup causes all proxy records with WakeUp.HMAC matching mDNSEthAddr 'e' to be deregistered, causing |
| 9687 | // multiple wakeup magic packets to be sent if appropriate, and all records to be ultimately freed after a few seconds. |
| 9688 | // ScheduleWakeup is called on mDNS record conflicts, ARP conflicts, NDP conflicts, or reception of trigger traffic |
| 9689 | // that warrants waking the sleeping host. |
| 9690 | // ScheduleWakeup must be called with the lock held (ScheduleWakeupForList uses mDNS_Deregister_internal) |
| 9691 | |
| 9692 | mDNSlocal void ScheduleWakeupForList(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e, AuthRecord *const thelist) |
| 9693 | { |
| 9694 | // We need to use the m->CurrentRecord mechanism here when dealing with DuplicateRecords list as |
| 9695 | // mDNS_Deregister_internal deregisters duplicate records immediately as they are not used |
| 9696 | // to send wakeups or goodbyes. See the comment in that function for more details. To keep it |
| 9697 | // simple, we use the same mechanism for both lists. |
| 9698 | if (!e->l[0]) |
| 9699 | { |
| 9700 | LogMsg("ScheduleWakeupForList ERROR: Target HMAC is zero" ); |
| 9701 | return; |
| 9702 | } |
| 9703 | m->CurrentRecord = thelist; |
| 9704 | while (m->CurrentRecord) |
| 9705 | { |
| 9706 | AuthRecord *const rr = m->CurrentRecord; |
| 9707 | if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && mDNSSameEthAddress(&rr->WakeUp.HMAC, e)) |
| 9708 | { |
| 9709 | LogInfo("ScheduleWakeupForList: Scheduling wakeup packets for %s" , ARDisplayString(m, rr)); |
| 9710 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); |
| 9711 | } |
| 9712 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 9713 | m->CurrentRecord = rr->next; |
| 9714 | } |
| 9715 | } |
| 9716 | |
| 9717 | mDNSlocal void ScheduleWakeup(mDNS *const m, mDNSInterfaceID InterfaceID, mDNSEthAddr *e) |
| 9718 | { |
| 9719 | if (!e->l[0]) { LogMsg("ScheduleWakeup ERROR: Target HMAC is zero" ); return; } |
| 9720 | ScheduleWakeupForList(m, InterfaceID, e, m->DuplicateRecords); |
| 9721 | ScheduleWakeupForList(m, InterfaceID, e, m->ResourceRecords); |
| 9722 | } |
| 9723 | |
| 9724 | mDNSlocal void SPSRecordCallback(mDNS *const m, AuthRecord *const ar, mStatus result) |
| 9725 | { |
| 9726 | if (result && result != mStatus_MemFree) |
| 9727 | LogInfo("SPS Callback %d %s" , result, ARDisplayString(m, ar)); |
| 9728 | |
| 9729 | if (result == mStatus_NameConflict) |
| 9730 | { |
| 9731 | mDNS_Lock(m); |
| 9732 | LogMsg("%-7s Conflicting mDNS -- waking %.6a %s" , InterfaceNameForID(m, ar->resrec.InterfaceID), &ar->WakeUp.HMAC, ARDisplayString(m, ar)); |
| 9733 | if (ar->WakeUp.HMAC.l[0]) |
| 9734 | { |
| 9735 | SendWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.IMAC, &ar->WakeUp.password, mDNSfalse); // Send one wakeup magic packet |
| 9736 | ScheduleWakeup(m, ar->resrec.InterfaceID, &ar->WakeUp.HMAC); // Schedule all other records with the same owner to be woken |
| 9737 | } |
| 9738 | mDNS_Unlock(m); |
| 9739 | } |
| 9740 | |
| 9741 | if (result == mStatus_NameConflict || result == mStatus_MemFree) |
| 9742 | { |
| 9743 | m->ProxyRecords--; |
| 9744 | mDNSPlatformMemFree(ar); |
| 9745 | mDNS_UpdateAllowSleep(m); |
| 9746 | } |
| 9747 | } |
| 9748 | |
| 9749 | mDNSlocal mDNSu8 *GetValueForMACAddr(mDNSu8 *ptr, mDNSu8 *limit, mDNSEthAddr *eth) |
| 9750 | { |
| 9751 | int i; |
| 9752 | mDNSs8 hval = 0; |
| 9753 | int colons = 0; |
| 9754 | mDNSu8 val = 0; |
| 9755 | |
| 9756 | for (i = 0; ptr < limit && *ptr != ' ' && i < 17; i++, ptr++) |
| 9757 | { |
| 9758 | hval = HexVal(*ptr); |
| 9759 | if (hval != -1) |
| 9760 | { |
| 9761 | val <<= 4; |
| 9762 | val |= hval; |
| 9763 | } |
| 9764 | else if (*ptr == ':') |
| 9765 | { |
| 9766 | if (colons >=5) |
| 9767 | { |
| 9768 | LogMsg("GetValueForMACAddr: Address malformed colons %d val %d" , colons, val); |
| 9769 | return mDNSNULL; |
| 9770 | } |
| 9771 | eth->b[colons] = val; |
| 9772 | colons++; |
| 9773 | val = 0; |
| 9774 | } |
| 9775 | } |
| 9776 | if (colons != 5) |
| 9777 | { |
| 9778 | LogMsg("GetValueForMACAddr: Address malformed colons %d" , colons); |
| 9779 | return mDNSNULL; |
| 9780 | } |
| 9781 | eth->b[colons] = val; |
| 9782 | return ptr; |
| 9783 | } |
| 9784 | |
| 9785 | mDNSlocal mDNSu8 *GetValueForIPv6Addr(mDNSu8 *ptr, mDNSu8 *limit, mDNSv6Addr *v6) |
| 9786 | { |
| 9787 | int hval; |
| 9788 | int value; |
| 9789 | int numBytes; |
| 9790 | int digitsProcessed; |
| 9791 | int zeroFillStart; |
| 9792 | int numColons; |
| 9793 | mDNSu8 v6addr[16]; |
| 9794 | |
| 9795 | // RFC 3513: Section 2.2 specifies IPv6 presentation format. The following parsing |
| 9796 | // handles both (1) and (2) and does not handle embedded IPv4 addresses. |
| 9797 | // |
| 9798 | // First forms a address in "v6addr", then expands to fill the zeroes in and returns |
| 9799 | // the result in "v6" |
| 9800 | |
| 9801 | numColons = numBytes = value = digitsProcessed = zeroFillStart = 0; |
| 9802 | while (ptr < limit && *ptr != ' ') |
| 9803 | { |
| 9804 | hval = HexVal(*ptr); |
| 9805 | if (hval != -1) |
| 9806 | { |
| 9807 | value <<= 4; |
| 9808 | value |= hval; |
| 9809 | digitsProcessed = 1; |
| 9810 | } |
| 9811 | else if (*ptr == ':') |
| 9812 | { |
| 9813 | if (!digitsProcessed) |
| 9814 | { |
| 9815 | // If we have already seen a "::", we should not see one more. Handle the special |
| 9816 | // case of "::" |
| 9817 | if (numColons) |
| 9818 | { |
| 9819 | // if we never filled any bytes and the next character is space (we have reached the end) |
| 9820 | // we are done |
| 9821 | if (!numBytes && (ptr + 1) < limit && *(ptr + 1) == ' ') |
| 9822 | { |
| 9823 | mDNSPlatformMemZero(v6->b, 16); |
| 9824 | return ptr + 1; |
| 9825 | } |
| 9826 | LogMsg("GetValueForIPv6Addr: zeroFillStart non-zero %d" , zeroFillStart); |
| 9827 | return mDNSNULL; |
| 9828 | } |
| 9829 | |
| 9830 | // We processed "::". We need to fill zeroes later. For now, mark the |
| 9831 | // point where we will start filling zeroes from. |
| 9832 | zeroFillStart = numBytes; |
| 9833 | numColons++; |
| 9834 | } |
| 9835 | else if ((ptr + 1) < limit && *(ptr + 1) == ' ') |
| 9836 | { |
| 9837 | // We have a trailing ":" i.e., no more characters after ":" |
| 9838 | LogMsg("GetValueForIPv6Addr: Trailing colon" ); |
| 9839 | return mDNSNULL; |
| 9840 | } |
| 9841 | else |
| 9842 | { |
| 9843 | // For a fully expanded IPv6 address, we fill the 14th and 15th byte outside of this while |
| 9844 | // loop below as there is no ":" at the end. Hence, the last two bytes that can possibly |
| 9845 | // filled here is 12 and 13. |
| 9846 | if (numBytes > 13) { LogMsg("GetValueForIPv6Addr:1: numBytes is %d" , numBytes); return mDNSNULL; } |
| 9847 | |
| 9848 | v6addr[numBytes++] = (mDNSu8) ((value >> 8) & 0xFF); |
| 9849 | v6addr[numBytes++] = (mDNSu8) (value & 0xFF); |
| 9850 | digitsProcessed = value = 0; |
| 9851 | |
| 9852 | // Make sure that we did not fill the 13th and 14th byte above |
| 9853 | if (numBytes > 14) { LogMsg("GetValueForIPv6Addr:2: numBytes is %d" , numBytes); return mDNSNULL; } |
| 9854 | } |
| 9855 | } |
| 9856 | ptr++; |
| 9857 | } |
| 9858 | |
| 9859 | // We should be processing the last set of bytes following the last ":" here |
| 9860 | if (!digitsProcessed) |
| 9861 | { |
| 9862 | LogMsg("GetValueForIPv6Addr: no trailing bytes after colon, numBytes is %d" , numBytes); |
| 9863 | return mDNSNULL; |
| 9864 | } |
| 9865 | |
| 9866 | if (numBytes > 14) { LogMsg("GetValueForIPv6Addr:3: numBytes is %d" , numBytes); return mDNSNULL; } |
| 9867 | v6addr[numBytes++] = (mDNSu8) ((value >> 8) & 0xFF); |
| 9868 | v6addr[numBytes++] = (mDNSu8) (value & 0xFF); |
| 9869 | |
| 9870 | if (zeroFillStart) |
| 9871 | { |
| 9872 | int i, j, n; |
| 9873 | for (i = 0; i < zeroFillStart; i++) |
| 9874 | v6->b[i] = v6addr[i]; |
| 9875 | for (j = i, n = 0; n < 16 - numBytes; j++, n++) |
| 9876 | v6->b[j] = 0; |
| 9877 | for (; j < 16; i++, j++) |
| 9878 | v6->b[j] = v6addr[i]; |
| 9879 | } |
| 9880 | else if (numBytes == 16) |
| 9881 | mDNSPlatformMemCopy(v6->b, v6addr, 16); |
| 9882 | else |
| 9883 | { |
| 9884 | LogMsg("GetValueForIPv6addr: Not enough bytes for IPv6 address, numBytes is %d" , numBytes); |
| 9885 | return mDNSNULL; |
| 9886 | } |
| 9887 | return ptr; |
| 9888 | } |
| 9889 | |
| 9890 | mDNSlocal mDNSu8 *GetValueForIPv4Addr(mDNSu8 *ptr, mDNSu8 *limit, mDNSv4Addr *v4) |
| 9891 | { |
| 9892 | mDNSu32 val; |
| 9893 | int dots = 0; |
| 9894 | val = 0; |
| 9895 | |
| 9896 | for ( ; ptr < limit && *ptr != ' '; ptr++) |
| 9897 | { |
| 9898 | if (*ptr >= '0' && *ptr <= '9') |
| 9899 | val = val * 10 + *ptr - '0'; |
| 9900 | else if (*ptr == '.') |
| 9901 | { |
| 9902 | if (val > 255 || dots >= 3) |
| 9903 | { |
| 9904 | LogMsg("GetValueForIPv4Addr: something wrong ptr(%p) %c, limit %p, dots %d" , ptr, *ptr, limit, dots); |
| 9905 | return mDNSNULL; |
| 9906 | } |
| 9907 | v4->b[dots++] = val; |
| 9908 | val = 0; |
| 9909 | } |
| 9910 | else |
| 9911 | { |
| 9912 | // We have a zero at the end and if we reached that, then we are done. |
| 9913 | if (*ptr == 0 && ptr == limit - 1 && dots == 3) |
| 9914 | { |
| 9915 | v4->b[dots] = val; |
| 9916 | return ptr + 1; |
| 9917 | } |
| 9918 | else { LogMsg("GetValueForIPv4Addr: something wrong ptr(%p) %c, limit %p, dots %d" , ptr, *ptr, limit, dots); return mDNSNULL; } |
| 9919 | } |
| 9920 | } |
| 9921 | if (dots != 3) { LogMsg("GetValueForIPv4Addr: Address malformed dots %d" , dots); return mDNSNULL; } |
| 9922 | v4->b[dots] = val; |
| 9923 | return ptr; |
| 9924 | } |
| 9925 | |
| 9926 | mDNSlocal mDNSu8 *GetValueForKeepalive(mDNSu8 *ptr, mDNSu8 *limit, mDNSu32 *value) |
| 9927 | { |
| 9928 | mDNSu32 val; |
| 9929 | |
| 9930 | val = 0; |
| 9931 | for ( ; ptr < limit && *ptr != ' '; ptr++) |
| 9932 | { |
| 9933 | if (*ptr < '0' || *ptr > '9') |
| 9934 | { |
| 9935 | // We have a zero at the end and if we reached that, then we are done. |
| 9936 | if (*ptr == 0 && ptr == limit - 1) |
| 9937 | { |
| 9938 | *value = val; |
| 9939 | return ptr + 1; |
| 9940 | } |
| 9941 | else { LogMsg("GetValueForKeepalive: *ptr %d, ptr %p, limit %p, ptr +1 %d" , *ptr, ptr, limit, *(ptr + 1)); return mDNSNULL; } |
| 9942 | } |
| 9943 | val = val * 10 + *ptr - '0'; |
| 9944 | } |
| 9945 | *value = val; |
| 9946 | return ptr; |
| 9947 | } |
| 9948 | |
| 9949 | mDNSexport mDNSBool mDNSValidKeepAliveRecord(AuthRecord *rr) |
| 9950 | { |
| 9951 | mDNSAddr laddr, raddr; |
| 9952 | mDNSEthAddr eth; |
| 9953 | mDNSIPPort lport, rport; |
| 9954 | mDNSu32 timeout, seq, ack; |
| 9955 | mDNSu16 win; |
| 9956 | |
| 9957 | if (!mDNS_KeepaliveRecord(&rr->resrec)) |
| 9958 | { |
| 9959 | return mDNSfalse; |
| 9960 | } |
| 9961 | |
| 9962 | timeout = seq = ack = 0; |
| 9963 | win = 0; |
| 9964 | laddr = raddr = zeroAddr; |
| 9965 | lport = rport = zeroIPPort; |
| 9966 | eth = zeroEthAddr; |
| 9967 | |
| 9968 | mDNS_ExtractKeepaliveInfo(rr, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); |
| 9969 | |
| 9970 | if (mDNSAddressIsZero(&laddr) || mDNSIPPortIsZero(lport) || |
| 9971 | mDNSAddressIsZero(&raddr) || mDNSIPPortIsZero(rport) || |
| 9972 | mDNSEthAddressIsZero(eth)) |
| 9973 | { |
| 9974 | return mDNSfalse; |
| 9975 | } |
| 9976 | |
| 9977 | return mDNStrue; |
| 9978 | } |
| 9979 | |
| 9980 | |
| 9981 | mDNSlocal void (AuthRecord *ar, mDNSu32 *timeout, mDNSAddr *laddr, mDNSAddr *raddr, mDNSEthAddr *eth, mDNSu32 *seq, |
| 9982 | mDNSu32 *ack, mDNSIPPort *lport, mDNSIPPort *rport, mDNSu16 *win) |
| 9983 | { |
| 9984 | if (ar->resrec.rrtype != kDNSType_NULL) |
| 9985 | return; |
| 9986 | |
| 9987 | if (mDNS_KeepaliveRecord(&ar->resrec)) |
| 9988 | { |
| 9989 | int len = ar->resrec.rdlength; |
| 9990 | mDNSu8 *ptr = &ar->resrec.rdata->u.txt.c[1]; |
| 9991 | mDNSu8 *limit = ptr + len - 1; // Exclude the first byte that is the length |
| 9992 | mDNSu32 value = 0; |
| 9993 | |
| 9994 | while (ptr < limit) |
| 9995 | { |
| 9996 | mDNSu8 param = *ptr; |
| 9997 | ptr += 2; // Skip the letter and the "=" |
| 9998 | if (param == 'h') |
| 9999 | { |
| 10000 | laddr->type = mDNSAddrType_IPv4; |
| 10001 | ptr = GetValueForIPv4Addr(ptr, limit, &laddr->ip.v4); |
| 10002 | } |
| 10003 | else if (param == 'd') |
| 10004 | { |
| 10005 | raddr->type = mDNSAddrType_IPv4; |
| 10006 | ptr = GetValueForIPv4Addr(ptr, limit, &raddr->ip.v4); |
| 10007 | } |
| 10008 | else if (param == 'H') |
| 10009 | { |
| 10010 | laddr->type = mDNSAddrType_IPv6; |
| 10011 | ptr = GetValueForIPv6Addr(ptr, limit, &laddr->ip.v6); |
| 10012 | } |
| 10013 | else if (param == 'D') |
| 10014 | { |
| 10015 | raddr->type = mDNSAddrType_IPv6; |
| 10016 | ptr = GetValueForIPv6Addr(ptr, limit, &raddr->ip.v6); |
| 10017 | } |
| 10018 | else if (param == 'm') |
| 10019 | { |
| 10020 | ptr = GetValueForMACAddr(ptr, limit, eth); |
| 10021 | } |
| 10022 | else |
| 10023 | { |
| 10024 | ptr = GetValueForKeepalive(ptr, limit, &value); |
| 10025 | } |
| 10026 | if (!ptr) { LogMsg("mDNS_ExtractKeepaliveInfo: Cannot parse\n" ); return; } |
| 10027 | |
| 10028 | // Extract everything in network order so that it is easy for sending a keepalive and also |
| 10029 | // for matching incoming TCP packets |
| 10030 | switch (param) |
| 10031 | { |
| 10032 | case 't': |
| 10033 | *timeout = value; |
| 10034 | //if (*timeout < 120) *timeout = 120; |
| 10035 | break; |
| 10036 | case 'h': |
| 10037 | case 'H': |
| 10038 | case 'd': |
| 10039 | case 'D': |
| 10040 | case 'm': |
| 10041 | case 'i': |
| 10042 | case 'c': |
| 10043 | break; |
| 10044 | case 'l': |
| 10045 | lport->NotAnInteger = swap16((mDNSu16)value); |
| 10046 | break; |
| 10047 | case 'r': |
| 10048 | rport->NotAnInteger = swap16((mDNSu16)value); |
| 10049 | break; |
| 10050 | case 's': |
| 10051 | *seq = swap32(value); |
| 10052 | break; |
| 10053 | case 'a': |
| 10054 | *ack = swap32(value); |
| 10055 | break; |
| 10056 | case 'w': |
| 10057 | *win = swap16((mDNSu16)value); |
| 10058 | break; |
| 10059 | default: |
| 10060 | LogMsg("mDNS_ExtractKeepaliveInfo: unknown value %c\n" , param); |
| 10061 | ptr = limit; |
| 10062 | break; |
| 10063 | } |
| 10064 | ptr++; // skip the space |
| 10065 | } |
| 10066 | } |
| 10067 | } |
| 10068 | |
| 10069 | // Matches the proxied auth records to the incoming TCP packet and returns the match and its sequence and ack in "rseq" and "rack" so that |
| 10070 | // the clients need not retrieve this information from the auth record again. |
| 10071 | mDNSlocal AuthRecord* mDNS_MatchKeepaliveInfo(mDNS *const m, const mDNSAddr* pladdr, const mDNSAddr* praddr, const mDNSIPPort plport, |
| 10072 | const mDNSIPPort prport, mDNSu32 *rseq, mDNSu32 *rack) |
| 10073 | { |
| 10074 | AuthRecord *ar; |
| 10075 | mDNSAddr laddr, raddr; |
| 10076 | mDNSEthAddr eth; |
| 10077 | mDNSIPPort lport, rport; |
| 10078 | mDNSu32 timeout, seq, ack; |
| 10079 | mDNSu16 win; |
| 10080 | |
| 10081 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 10082 | { |
| 10083 | timeout = seq = ack = 0; |
| 10084 | win = 0; |
| 10085 | laddr = raddr = zeroAddr; |
| 10086 | lport = rport = zeroIPPort; |
| 10087 | |
| 10088 | if (!ar->WakeUp.HMAC.l[0]) continue; |
| 10089 | |
| 10090 | mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); |
| 10091 | |
| 10092 | // Did we parse correctly ? |
| 10093 | if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win) |
| 10094 | { |
| 10095 | debugf("mDNS_MatchKeepaliveInfo: not a valid record %s for keepalive" , ARDisplayString(m, ar)); |
| 10096 | continue; |
| 10097 | } |
| 10098 | |
| 10099 | debugf("mDNS_MatchKeepaliveInfo: laddr %#a pladdr %#a, raddr %#a praddr %#a, lport %d plport %d, rport %d prport %d" , |
| 10100 | &laddr, pladdr, &raddr, praddr, mDNSVal16(lport), mDNSVal16(plport), mDNSVal16(rport), mDNSVal16(prport)); |
| 10101 | |
| 10102 | // Does it match the incoming TCP packet ? |
| 10103 | if (mDNSSameAddress(&laddr, pladdr) && mDNSSameAddress(&raddr, praddr) && mDNSSameIPPort(lport, plport) && mDNSSameIPPort(rport, prport)) |
| 10104 | { |
| 10105 | // returning in network order |
| 10106 | *rseq = seq; |
| 10107 | *rack = ack; |
| 10108 | return ar; |
| 10109 | } |
| 10110 | } |
| 10111 | return mDNSNULL; |
| 10112 | } |
| 10113 | |
| 10114 | mDNSlocal void mDNS_SendKeepalives(mDNS *const m) |
| 10115 | { |
| 10116 | AuthRecord *ar; |
| 10117 | |
| 10118 | for (ar = m->ResourceRecords; ar; ar=ar->next) |
| 10119 | { |
| 10120 | mDNSu32 timeout, seq, ack; |
| 10121 | mDNSu16 win; |
| 10122 | mDNSAddr laddr, raddr; |
| 10123 | mDNSEthAddr eth; |
| 10124 | mDNSIPPort lport, rport; |
| 10125 | |
| 10126 | timeout = seq = ack = 0; |
| 10127 | win = 0; |
| 10128 | |
| 10129 | laddr = raddr = zeroAddr; |
| 10130 | lport = rport = zeroIPPort; |
| 10131 | |
| 10132 | if (!ar->WakeUp.HMAC.l[0]) continue; |
| 10133 | |
| 10134 | mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); |
| 10135 | |
| 10136 | if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win) |
| 10137 | { |
| 10138 | debugf("mDNS_SendKeepalives: not a valid record %s for keepalive" , ARDisplayString(m, ar)); |
| 10139 | continue; |
| 10140 | } |
| 10141 | LogMsg("mDNS_SendKeepalives: laddr %#a raddr %#a lport %d rport %d" , &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport)); |
| 10142 | |
| 10143 | // When we receive a proxy update, we set KATimeExpire to zero so that we always send a keepalive |
| 10144 | // immediately (to detect any potential problems). After that we always set it to a non-zero value. |
| 10145 | if (!ar->KATimeExpire || (m->timenow - ar->KATimeExpire >= 0)) |
| 10146 | { |
| 10147 | mDNSPlatformSendKeepalive(&laddr, &raddr, &lport, &rport, seq, ack, win); |
| 10148 | ar->KATimeExpire = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); |
| 10149 | } |
| 10150 | if (m->NextScheduledKA - ar->KATimeExpire > 0) |
| 10151 | m->NextScheduledKA = ar->KATimeExpire; |
| 10152 | } |
| 10153 | } |
| 10154 | |
| 10155 | mDNSlocal void mDNS_SendKeepaliveACK(mDNS *const m, AuthRecord *ar) |
| 10156 | { |
| 10157 | mDNSu32 timeout, seq, ack, seqInc; |
| 10158 | mDNSu16 win; |
| 10159 | mDNSAddr laddr, raddr; |
| 10160 | mDNSEthAddr eth; |
| 10161 | mDNSIPPort lport, rport; |
| 10162 | mDNSu8 *ptr; |
| 10163 | |
| 10164 | if (ar == mDNSNULL) |
| 10165 | { |
| 10166 | LogInfo("mDNS_SendKeepalivesACK: AuthRecord is NULL" ); |
| 10167 | return; |
| 10168 | } |
| 10169 | |
| 10170 | timeout = seq = ack = 0; |
| 10171 | win = 0; |
| 10172 | |
| 10173 | laddr = raddr = zeroAddr; |
| 10174 | lport = rport = zeroIPPort; |
| 10175 | |
| 10176 | mDNS_ExtractKeepaliveInfo(ar, &timeout, &laddr, &raddr, ð, &seq, &ack, &lport, &rport, &win); |
| 10177 | |
| 10178 | if (!timeout || mDNSAddressIsZero(&laddr) || mDNSAddressIsZero(&raddr) || !seq || !ack || mDNSIPPortIsZero(lport) || mDNSIPPortIsZero(rport) || !win) |
| 10179 | { |
| 10180 | LogInfo("mDNS_SendKeepaliveACK: not a valid record %s for keepalive" , ARDisplayString(m, ar)); |
| 10181 | return; |
| 10182 | } |
| 10183 | |
| 10184 | // To send a keepalive ACK, we need to add one to the sequence number from the keepalive |
| 10185 | // record, which is the TCP connection's "next" sequence number minus one. Otherwise, the |
| 10186 | // keepalive ACK also ends up being a keepalive probe. Also, seq is in network byte order, so |
| 10187 | // it's converted to host byte order before incrementing it by one. |
| 10188 | ptr = (mDNSu8 *)&seq; |
| 10189 | seqInc = (mDNSu32)((ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3]) + 1; |
| 10190 | ptr[0] = (mDNSu8)((seqInc >> 24) & 0xFF); |
| 10191 | ptr[1] = (mDNSu8)((seqInc >> 16) & 0xFF); |
| 10192 | ptr[2] = (mDNSu8)((seqInc >> 8) & 0xFF); |
| 10193 | ptr[3] = (mDNSu8)((seqInc ) & 0xFF); |
| 10194 | LogMsg("mDNS_SendKeepaliveACK: laddr %#a raddr %#a lport %d rport %d" , &laddr, &raddr, mDNSVal16(lport), mDNSVal16(rport)); |
| 10195 | mDNSPlatformSendKeepalive(&laddr, &raddr, &lport, &rport, seq, ack, win); |
| 10196 | } |
| 10197 | |
| 10198 | mDNSlocal void mDNSCoreReceiveUpdate(mDNS *const m, |
| 10199 | const DNSMessage *const msg, const mDNSu8 *end, |
| 10200 | const mDNSAddr *srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, mDNSIPPort dstport, |
| 10201 | const mDNSInterfaceID InterfaceID) |
| 10202 | { |
| 10203 | int i; |
| 10204 | AuthRecord opt; |
| 10205 | mDNSu8 *p = m->omsg.data; |
| 10206 | OwnerOptData owner = zeroOwner; // Need to zero this, so we'll know if this Update packet was missing its Owner option |
| 10207 | mDNSu32 updatelease = 0; |
| 10208 | const mDNSu8 *ptr; |
| 10209 | |
| 10210 | LogSPS("Received Update from %#-15a:%-5d to %#-15a:%-5d on 0x%p with " |
| 10211 | "%2d Question%s %2d Answer%s %2d Authorit%s %2d Additional%s %d bytes" , |
| 10212 | srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), InterfaceID, |
| 10213 | msg->h.numQuestions, msg->h.numQuestions == 1 ? ", " : "s," , |
| 10214 | msg->h.numAnswers, msg->h.numAnswers == 1 ? ", " : "s," , |
| 10215 | msg->h.numAuthorities, msg->h.numAuthorities == 1 ? "y, " : "ies," , |
| 10216 | msg->h.numAdditionals, msg->h.numAdditionals == 1 ? " " : "s" , end - msg->data); |
| 10217 | |
| 10218 | if (!InterfaceID || !m->SPSSocket || !mDNSSameIPPort(dstport, m->SPSSocket->port)) return; |
| 10219 | |
| 10220 | if (mDNS_PacketLoggingEnabled) |
| 10221 | DumpPacket(m, mStatus_NoError, mDNSfalse, "UDP" , srcaddr, srcport, dstaddr, dstport, msg, end); |
| 10222 | |
| 10223 | ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space + DNSOpt_OwnerData_ID_Space); |
| 10224 | if (ptr) |
| 10225 | { |
| 10226 | ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec); |
| 10227 | if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative && m->rec.r.resrec.rrtype == kDNSType_OPT) |
| 10228 | { |
| 10229 | const rdataOPT *o; |
| 10230 | const rdataOPT *const e = (const rdataOPT *)&m->rec.r.resrec.rdata->u.data[m->rec.r.resrec.rdlength]; |
| 10231 | for (o = &m->rec.r.resrec.rdata->u.opt[0]; o < e; o++) |
| 10232 | { |
| 10233 | if (o->opt == kDNSOpt_Lease) updatelease = o->u.updatelease; |
| 10234 | else if (o->opt == kDNSOpt_Owner && o->u.owner.vers == 0) owner = o->u.owner; |
| 10235 | } |
| 10236 | } |
| 10237 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 10238 | } |
| 10239 | |
| 10240 | InitializeDNSMessage(&m->omsg.h, msg->h.id, UpdateRespFlags); |
| 10241 | |
| 10242 | if (!updatelease || !owner.HMAC.l[0]) |
| 10243 | { |
| 10244 | static int msgs = 0; |
| 10245 | if (msgs < 100) |
| 10246 | { |
| 10247 | msgs++; |
| 10248 | LogMsg("Refusing sleep proxy registration from %#a:%d:%s%s" , srcaddr, mDNSVal16(srcport), |
| 10249 | !updatelease ? " No lease" : "" , !owner.HMAC.l[0] ? " No owner" : "" ); |
| 10250 | } |
| 10251 | m->omsg.h.flags.b[1] |= kDNSFlag1_RC_FormErr; |
| 10252 | } |
| 10253 | else if (m->ProxyRecords + msg->h.mDNS_numUpdates > MAX_PROXY_RECORDS) |
| 10254 | { |
| 10255 | static int msgs = 0; |
| 10256 | if (msgs < 100) |
| 10257 | { |
| 10258 | msgs++; |
| 10259 | LogMsg("Refusing sleep proxy registration from %#a:%d: Too many records %d + %d = %d > %d" , srcaddr, mDNSVal16(srcport), |
| 10260 | m->ProxyRecords, msg->h.mDNS_numUpdates, m->ProxyRecords + msg->h.mDNS_numUpdates, MAX_PROXY_RECORDS); |
| 10261 | } |
| 10262 | m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused; |
| 10263 | } |
| 10264 | else |
| 10265 | { |
| 10266 | LogSPS("Received Update for H-MAC %.6a I-MAC %.6a Password %.6a seq %d" , &owner.HMAC, &owner.IMAC, &owner.password, owner.seq); |
| 10267 | |
| 10268 | if (updatelease > 24 * 60 * 60) |
| 10269 | updatelease = 24 * 60 * 60; |
| 10270 | |
| 10271 | if (updatelease > 0x40000000UL / mDNSPlatformOneSecond) |
| 10272 | updatelease = 0x40000000UL / mDNSPlatformOneSecond; |
| 10273 | |
| 10274 | ptr = LocateAuthorities(msg, end); |
| 10275 | |
| 10276 | // Clear any stale TCP keepalive records that may exist |
| 10277 | ClearKeepaliveProxyRecords(m, &owner, m->DuplicateRecords, InterfaceID); |
| 10278 | ClearKeepaliveProxyRecords(m, &owner, m->ResourceRecords, InterfaceID); |
| 10279 | |
| 10280 | for (i = 0; i < msg->h.mDNS_numUpdates && ptr && ptr < end; i++) |
| 10281 | { |
| 10282 | ptr = GetLargeResourceRecord(m, msg, ptr, end, InterfaceID, kDNSRecordTypePacketAuth, &m->rec); |
| 10283 | if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) |
| 10284 | { |
| 10285 | mDNSu16 RDLengthMem = GetRDLengthMem(&m->rec.r.resrec); |
| 10286 | AuthRecord *ar = mDNSPlatformMemAllocate(sizeof(AuthRecord) - sizeof(RDataBody) + RDLengthMem); |
| 10287 | if (!ar) |
| 10288 | { |
| 10289 | m->omsg.h.flags.b[1] |= kDNSFlag1_RC_Refused; |
| 10290 | break; |
| 10291 | } |
| 10292 | else |
| 10293 | { |
| 10294 | mDNSu8 RecordType = m->rec.r.resrec.RecordType & kDNSRecordTypePacketUniqueMask ? kDNSRecordTypeUnique : kDNSRecordTypeShared; |
| 10295 | m->rec.r.resrec.rrclass &= ~kDNSClass_UniqueRRSet; |
| 10296 | // All stale keepalive records have been flushed prior to this loop. |
| 10297 | if (!mDNS_KeepaliveRecord(&m->rec.r.resrec)) |
| 10298 | { |
| 10299 | ClearIdenticalProxyRecords(m, &owner, m->DuplicateRecords); // Make sure we don't have any old stale duplicates of this record |
| 10300 | ClearIdenticalProxyRecords(m, &owner, m->ResourceRecords); |
| 10301 | } |
| 10302 | mDNS_SetupResourceRecord(ar, mDNSNULL, InterfaceID, m->rec.r.resrec.rrtype, m->rec.r.resrec.rroriginalttl, RecordType, AuthRecordAny, SPSRecordCallback, ar); |
| 10303 | AssignDomainName(&ar->namestorage, m->rec.r.resrec.name); |
| 10304 | ar->resrec.rdlength = GetRDLength(&m->rec.r.resrec, mDNSfalse); |
| 10305 | ar->resrec.rdata->MaxRDLength = RDLengthMem; |
| 10306 | mDNSPlatformMemCopy(ar->resrec.rdata->u.data, m->rec.r.resrec.rdata->u.data, RDLengthMem); |
| 10307 | ar->ForceMCast = mDNStrue; |
| 10308 | ar->WakeUp = owner; |
| 10309 | if (m->rec.r.resrec.rrtype == kDNSType_PTR) |
| 10310 | { |
| 10311 | mDNSs32 t = ReverseMapDomainType(m->rec.r.resrec.name); |
| 10312 | if (t == mDNSAddrType_IPv4) GetIPv4FromName(&ar->AddressProxy, m->rec.r.resrec.name); |
| 10313 | else if (t == mDNSAddrType_IPv6) GetIPv6FromName(&ar->AddressProxy, m->rec.r.resrec.name); |
| 10314 | debugf("mDNSCoreReceiveUpdate: PTR %d %d %#a %s" , t, ar->AddressProxy.type, &ar->AddressProxy, ARDisplayString(m, ar)); |
| 10315 | if (ar->AddressProxy.type) SetSPSProxyListChanged(InterfaceID); |
| 10316 | } |
| 10317 | ar->TimeRcvd = m->timenow; |
| 10318 | ar->TimeExpire = m->timenow + updatelease * mDNSPlatformOneSecond; |
| 10319 | if (m->NextScheduledSPS - ar->TimeExpire > 0) |
| 10320 | m->NextScheduledSPS = ar->TimeExpire; |
| 10321 | ar->KATimeExpire = 0; |
| 10322 | mDNS_Register_internal(m, ar); |
| 10323 | |
| 10324 | m->ProxyRecords++; |
| 10325 | mDNS_UpdateAllowSleep(m); |
| 10326 | LogSPS("SPS Registered %4d %X %s" , m->ProxyRecords, RecordType, ARDisplayString(m,ar)); |
| 10327 | } |
| 10328 | } |
| 10329 | m->rec.r.resrec.RecordType = 0; // Clear RecordType to show we're not still using it |
| 10330 | } |
| 10331 | |
| 10332 | if (m->omsg.h.flags.b[1] & kDNSFlag1_RC_Mask) |
| 10333 | { |
| 10334 | LogMsg("Refusing sleep proxy registration from %#a:%d: Out of memory" , srcaddr, mDNSVal16(srcport)); |
| 10335 | ClearProxyRecords(m, &owner, m->DuplicateRecords); |
| 10336 | ClearProxyRecords(m, &owner, m->ResourceRecords); |
| 10337 | } |
| 10338 | else |
| 10339 | { |
| 10340 | mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 10341 | opt.resrec.rrclass = NormalMaxDNSMessageData; |
| 10342 | opt.resrec.rdlength = sizeof(rdataOPT); // One option in this OPT record |
| 10343 | opt.resrec.rdestimate = sizeof(rdataOPT); |
| 10344 | opt.resrec.rdata->u.opt[0].opt = kDNSOpt_Lease; |
| 10345 | opt.resrec.rdata->u.opt[0].u.updatelease = updatelease; |
| 10346 | p = PutResourceRecordTTLWithLimit(&m->omsg, p, &m->omsg.h.numAdditionals, &opt.resrec, opt.resrec.rroriginalttl, m->omsg.data + AbsoluteMaxDNSMessageData); |
| 10347 | } |
| 10348 | } |
| 10349 | |
| 10350 | if (p) mDNSSendDNSMessage(m, &m->omsg, p, InterfaceID, m->SPSSocket, srcaddr, srcport, mDNSNULL, mDNSNULL, mDNSfalse); |
| 10351 | mDNS_SendKeepalives(m); |
| 10352 | } |
| 10353 | |
| 10354 | mDNSlocal mDNSu32 mDNSGenerateOwnerOptForInterface(mDNS *const m, const mDNSInterfaceID InterfaceID, DNSMessage *msg) |
| 10355 | { |
| 10356 | mDNSu8 *ptr = msg->data; |
| 10357 | mDNSu8 *end = mDNSNULL; |
| 10358 | mDNSu32 length = 0; |
| 10359 | AuthRecord opt; |
| 10360 | NetworkInterfaceInfo *intf; |
| 10361 | |
| 10362 | mDNS_SetupResourceRecord(&opt, mDNSNULL, mDNSInterface_Any, kDNSType_OPT, kStandardTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 10363 | opt.resrec.rrclass = NormalMaxDNSMessageData; |
| 10364 | opt.resrec.rdlength = sizeof(rdataOPT); |
| 10365 | opt.resrec.rdestimate = sizeof(rdataOPT); |
| 10366 | |
| 10367 | intf = FirstInterfaceForID(m, InterfaceID); |
| 10368 | SetupOwnerOpt(m, intf, &opt.resrec.rdata->u.opt[0]); |
| 10369 | |
| 10370 | LogSPS("Generated OPT record : %s" , ARDisplayString(m, &opt)); |
| 10371 | end = PutResourceRecord(msg, ptr, &msg->h.numAdditionals, &opt.resrec); |
| 10372 | if (end != mDNSNULL) |
| 10373 | { |
| 10374 | // Put all the integer values in IETF byte-order (MSB first, LSB second) |
| 10375 | SwapDNSHeaderBytes(msg); |
| 10376 | length = (end - msg->data); |
| 10377 | } |
| 10378 | else |
| 10379 | LogSPS("mDNSGenerateOwnerOptForInterface: Failed to generate owner OPT record" ); |
| 10380 | |
| 10381 | return length; |
| 10382 | } |
| 10383 | |
| 10384 | // Note that this routine is called both for Sleep Proxy Registrations, and for Standard Dynamic |
| 10385 | // DNS registrations, but (currently) only has to handle the Sleep Proxy Registration reply case, |
| 10386 | // and should ignore Standard Dynamic DNS registration replies, because those are handled elsewhere. |
| 10387 | // Really, both should be unified and handled in one place. |
| 10388 | mDNSlocal void mDNSCoreReceiveUpdateR(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *end, const mDNSAddr *srcaddr, const mDNSInterfaceID InterfaceID) |
| 10389 | { |
| 10390 | if (InterfaceID) |
| 10391 | { |
| 10392 | mDNSu32 pktlease = 0, spsupdates = 0; |
| 10393 | const mDNSBool gotlease = GetPktLease(m, msg, end, &pktlease); |
| 10394 | const mDNSu32 updatelease = gotlease ? pktlease : 60 * 60; // If SPS fails to indicate lease time, assume one hour |
| 10395 | if (gotlease) LogSPS("DNS Update response contains lease option granting %4d seconds, updateid %d, InterfaceID %p" , updatelease, mDNSVal16(msg->h.id), InterfaceID); |
| 10396 | |
| 10397 | if (m->CurrentRecord) |
| 10398 | LogMsg("mDNSCoreReceiveUpdateR ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 10399 | m->CurrentRecord = m->ResourceRecords; |
| 10400 | while (m->CurrentRecord) |
| 10401 | { |
| 10402 | AuthRecord *const rr = m->CurrentRecord; |
| 10403 | if (rr->resrec.InterfaceID == InterfaceID || (!rr->resrec.InterfaceID && (rr->ForceMCast || IsLocalDomain(rr->resrec.name)))) |
| 10404 | if (mDNSSameOpaque16(rr->updateid, msg->h.id)) |
| 10405 | { |
| 10406 | // We successfully completed this record's registration on this "InterfaceID". Clear that bit. |
| 10407 | // Clear the updateid when we are done sending on all interfaces. |
| 10408 | mDNSu32 scopeid = mDNSPlatformInterfaceIndexfromInterfaceID(m, InterfaceID, mDNStrue); |
| 10409 | if (scopeid < (sizeof(rr->updateIntID) * mDNSNBBY)) |
| 10410 | bit_clr_opaque64(rr->updateIntID, scopeid); |
| 10411 | if (mDNSOpaque64IsZero(&rr->updateIntID)) |
| 10412 | rr->updateid = zeroID; |
| 10413 | rr->expire = NonZeroTime(m->timenow + updatelease * mDNSPlatformOneSecond); |
| 10414 | spsupdates++; |
| 10415 | LogSPS("Sleep Proxy %s record %2d %5d 0x%x 0x%x (%d) %s" , rr->WakeUp.HMAC.l[0] ? "transferred" : "registered" , spsupdates, updatelease, rr->updateIntID.l[1], rr->updateIntID.l[0], mDNSVal16(rr->updateid), ARDisplayString(m,rr)); |
| 10416 | if (rr->WakeUp.HMAC.l[0]) |
| 10417 | { |
| 10418 | rr->WakeUp.HMAC = zeroEthAddr; // Clear HMAC so that mDNS_Deregister_internal doesn't waste packets trying to wake this host |
| 10419 | rr->RequireGoodbye = mDNSfalse; // and we don't want to send goodbye for it |
| 10420 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); |
| 10421 | } |
| 10422 | } |
| 10423 | // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because |
| 10424 | // new records could have been added to the end of the list as a result of that call. |
| 10425 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 10426 | m->CurrentRecord = rr->next; |
| 10427 | } |
| 10428 | if (spsupdates) // Only do this dynamic store stuff if this was, in fact, a Sleep Proxy Update response |
| 10429 | { |
| 10430 | char *ifname; |
| 10431 | mDNSAddr spsaddr; |
| 10432 | DNSMessage optMsg; |
| 10433 | int length; |
| 10434 | // Update the dynamic store with the IP Address and MAC address of the sleep proxy |
| 10435 | ifname = InterfaceNameForID(m, InterfaceID); |
| 10436 | mDNSPlatformMemCopy(&spsaddr, srcaddr, sizeof (mDNSAddr)); |
| 10437 | mDNSPlatformStoreSPSMACAddr(&spsaddr, ifname); |
| 10438 | |
| 10439 | // Store the Owner OPT record for this interface. |
| 10440 | // Configd may use the OPT record if it detects a conflict with the BSP when the system wakes up |
| 10441 | InitializeDNSMessage(&optMsg.h, zeroID, ResponseFlags); |
| 10442 | length = mDNSGenerateOwnerOptForInterface(m, InterfaceID, &optMsg); |
| 10443 | if (length != 0) |
| 10444 | { |
| 10445 | length += sizeof(DNSMessageHeader); |
| 10446 | mDNSPlatformStoreOwnerOptRecord(ifname, &optMsg, length); |
| 10447 | } |
| 10448 | } |
| 10449 | } |
| 10450 | // If we were waiting to go to sleep, then this SPS registration or wide-area record deletion |
| 10451 | // may have been the thing we were waiting for, so schedule another check to see if we can sleep now. |
| 10452 | if (m->SleepLimit) m->NextScheduledSPRetry = m->timenow; |
| 10453 | } |
| 10454 | |
| 10455 | mDNSexport void MakeNegativeCacheRecord(mDNS *const m, CacheRecord *const cr, |
| 10456 | const domainname *const name, const mDNSu32 namehash, const mDNSu16 rrtype, const mDNSu16 rrclass, mDNSu32 ttl_seconds, mDNSInterfaceID InterfaceID, DNSServer *dnsserver) |
| 10457 | { |
| 10458 | if (cr == &m->rec.r && m->rec.r.resrec.RecordType) |
| 10459 | LogFatalError("MakeNegativeCacheRecord: m->rec appears to be already in use for %s" , CRDisplayString(m, &m->rec.r)); |
| 10460 | |
| 10461 | // Create empty resource record |
| 10462 | cr->resrec.RecordType = kDNSRecordTypePacketNegative; |
| 10463 | cr->resrec.InterfaceID = InterfaceID; |
| 10464 | cr->resrec.rDNSServer = dnsserver; |
| 10465 | cr->resrec.name = name; // Will be updated to point to cg->name when we call CreateNewCacheEntry |
| 10466 | cr->resrec.rrtype = rrtype; |
| 10467 | cr->resrec.rrclass = rrclass; |
| 10468 | cr->resrec.rroriginalttl = ttl_seconds; |
| 10469 | cr->resrec.rdlength = 0; |
| 10470 | cr->resrec.rdestimate = 0; |
| 10471 | cr->resrec.namehash = namehash; |
| 10472 | cr->resrec.rdatahash = 0; |
| 10473 | cr->resrec.rdata = (RData*)&cr->smallrdatastorage; |
| 10474 | cr->resrec.rdata->MaxRDLength = 0; |
| 10475 | |
| 10476 | cr->NextInKAList = mDNSNULL; |
| 10477 | cr->TimeRcvd = m->timenow; |
| 10478 | cr->DelayDelivery = 0; |
| 10479 | cr->NextRequiredQuery = m->timenow; |
| 10480 | cr->LastUsed = m->timenow; |
| 10481 | cr->CRActiveQuestion = mDNSNULL; |
| 10482 | cr->UnansweredQueries = 0; |
| 10483 | cr->LastUnansweredTime = 0; |
| 10484 | cr->NextInCFList = mDNSNULL; |
| 10485 | cr->nsec = mDNSNULL; |
| 10486 | cr->soa = mDNSNULL; |
| 10487 | cr->CRDNSSECQuestion = 0; |
| 10488 | // Initialize to the basic one and the caller can set it to more |
| 10489 | // specific based on the response if any |
| 10490 | cr->responseFlags = ResponseFlags; |
| 10491 | } |
| 10492 | |
| 10493 | mDNSexport void mDNSCoreReceive(mDNS *const m, DNSMessage *const msg, const mDNSu8 *const end, |
| 10494 | const mDNSAddr *const srcaddr, const mDNSIPPort srcport, const mDNSAddr *dstaddr, const mDNSIPPort dstport, |
| 10495 | const mDNSInterfaceID InterfaceID) |
| 10496 | { |
| 10497 | mDNSInterfaceID ifid = InterfaceID; |
| 10498 | const mDNSu8 *const pkt = (mDNSu8 *)msg; |
| 10499 | const mDNSu8 StdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_StdQuery; |
| 10500 | const mDNSu8 StdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_StdQuery; |
| 10501 | const mDNSu8 UpdQ = kDNSFlag0_QR_Query | kDNSFlag0_OP_Update; |
| 10502 | const mDNSu8 UpdR = kDNSFlag0_QR_Response | kDNSFlag0_OP_Update; |
| 10503 | mDNSu8 QR_OP; |
| 10504 | mDNSu8 *ptr = mDNSNULL; |
| 10505 | mDNSBool TLS = (dstaddr == (mDNSAddr *)1); // For debug logs: dstaddr = 0 means TCP; dstaddr = 1 means TLS |
| 10506 | if (TLS) dstaddr = mDNSNULL; |
| 10507 | |
| 10508 | #ifndef UNICAST_DISABLED |
| 10509 | if (mDNSSameAddress(srcaddr, &m->Router)) |
| 10510 | { |
| 10511 | #ifdef _LEGACY_NAT_TRAVERSAL_ |
| 10512 | if (mDNSSameIPPort(srcport, SSDPPort) || (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port))) |
| 10513 | { |
| 10514 | mDNS_Lock(m); |
| 10515 | LNT_ConfigureRouterInfo(m, InterfaceID, (mDNSu8 *)msg, (mDNSu16)(end - pkt)); |
| 10516 | mDNS_Unlock(m); |
| 10517 | return; |
| 10518 | } |
| 10519 | #endif |
| 10520 | if (mDNSSameIPPort(srcport, NATPMPPort)) |
| 10521 | { |
| 10522 | mDNS_Lock(m); |
| 10523 | uDNS_ReceiveNATPacket(m, InterfaceID, (mDNSu8 *)msg, (mDNSu16)(end - pkt)); |
| 10524 | mDNS_Unlock(m); |
| 10525 | return; |
| 10526 | } |
| 10527 | } |
| 10528 | #ifdef _LEGACY_NAT_TRAVERSAL_ |
| 10529 | else if (m->SSDPSocket && mDNSSameIPPort(dstport, m->SSDPSocket->port)) { debugf("Ignoring SSDP response from %#a:%d" , srcaddr, mDNSVal16(srcport)); return; } |
| 10530 | #endif |
| 10531 | |
| 10532 | #endif |
| 10533 | if ((unsigned)(end - pkt) < sizeof(DNSMessageHeader)) |
| 10534 | { |
| 10535 | LogMsg("DNS Message from %#a:%d to %#a:%d length %d too short" , srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), (int)(end - pkt)); |
| 10536 | return; |
| 10537 | } |
| 10538 | QR_OP = (mDNSu8)(msg->h.flags.b[0] & kDNSFlag0_QROP_Mask); |
| 10539 | // Read the integer parts which are in IETF byte-order (MSB first, LSB second) |
| 10540 | ptr = (mDNSu8 *)&msg->h.numQuestions; |
| 10541 | msg->h.numQuestions = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); |
| 10542 | msg->h.numAnswers = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); |
| 10543 | msg->h.numAuthorities = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]); |
| 10544 | msg->h.numAdditionals = (mDNSu16)((mDNSu16)ptr[6] << 8 | ptr[7]); |
| 10545 | |
| 10546 | if (!m) { LogMsg("mDNSCoreReceive ERROR m is NULL" ); return; } |
| 10547 | |
| 10548 | // We use zero addresses and all-ones addresses at various places in the code to indicate special values like "no address" |
| 10549 | // If we accept and try to process a packet with zero or all-ones source address, that could really mess things up |
| 10550 | if (srcaddr && !mDNSAddressIsValid(srcaddr)) { debugf("mDNSCoreReceive ignoring packet from %#a" , srcaddr); return; } |
| 10551 | |
| 10552 | mDNS_Lock(m); |
| 10553 | m->PktNum++; |
| 10554 | if (mDNSOpaque16IsZero(msg->h.id)) |
| 10555 | { |
| 10556 | m->MPktNum++; |
| 10557 | #if APPLE_OSX_mDNSResponder |
| 10558 | // Track the number of multicast packets received from a source outside our subnet. |
| 10559 | // Check the destination address to avoid accounting for spurious packets that |
| 10560 | // comes in with message id zero. |
| 10561 | if (!mDNS_AddressIsLocalSubnet(m, InterfaceID, srcaddr) && dstaddr && |
| 10562 | mDNSAddressIsAllDNSLinkGroup(dstaddr)) |
| 10563 | { |
| 10564 | m->RemoteSubnet++; |
| 10565 | } |
| 10566 | #endif // #if APPLE_OSX_mDNSResponder |
| 10567 | } |
| 10568 | |
| 10569 | #ifndef UNICAST_DISABLED |
| 10570 | if (!dstaddr || (!mDNSAddressIsAllDNSLinkGroup(dstaddr) && (QR_OP == StdR || QR_OP == UpdR))) |
| 10571 | if (!mDNSOpaque16IsZero(msg->h.id)) // uDNS_ReceiveMsg only needs to get real uDNS responses, not "QU" mDNS responses |
| 10572 | { |
| 10573 | ifid = mDNSInterface_Any; |
| 10574 | if (mDNS_PacketLoggingEnabled) |
| 10575 | DumpPacket(m, mStatus_NoError, mDNSfalse, TLS ? "TLS" : !dstaddr ? "TCP" : "UDP" , srcaddr, srcport, dstaddr, dstport, msg, end); |
| 10576 | uDNS_ReceiveMsg(m, msg, end, srcaddr, srcport); |
| 10577 | // Note: mDNSCore also needs to get access to received unicast responses |
| 10578 | } |
| 10579 | #endif |
| 10580 | if (QR_OP == StdQ) mDNSCoreReceiveQuery (m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid); |
| 10581 | else if (QR_OP == StdR) mDNSCoreReceiveResponse(m, msg, end, srcaddr, srcport, dstaddr, dstport, ifid); |
| 10582 | else if (QR_OP == UpdQ) mDNSCoreReceiveUpdate (m, msg, end, srcaddr, srcport, dstaddr, dstport, InterfaceID); |
| 10583 | else if (QR_OP == UpdR) mDNSCoreReceiveUpdateR (m, msg, end, srcaddr, InterfaceID); |
| 10584 | else |
| 10585 | { |
| 10586 | if (mDNS_LoggingEnabled) |
| 10587 | { |
| 10588 | static int msgCount = 0; |
| 10589 | if (msgCount < 1000) { |
| 10590 | int i = 0; |
| 10591 | msgCount++; |
| 10592 | LogInfo("Unknown DNS packet type %02X%02X from %#-15a:%-5d to %#-15a:%-5d length %d on %p (ignored)" , |
| 10593 | msg->h.flags.b[0], msg->h.flags.b[1], srcaddr, mDNSVal16(srcport), dstaddr, mDNSVal16(dstport), (int)(end - pkt), InterfaceID); |
| 10594 | while (i < (int)(end - pkt)) |
| 10595 | { |
| 10596 | char buffer[128]; |
| 10597 | char *p = buffer + mDNS_snprintf(buffer, sizeof(buffer), "%04X" , i); |
| 10598 | do if (i < (int)(end - pkt)) p += mDNS_snprintf(p, sizeof(buffer), " %02X" , pkt[i]);while (++i & 15); |
| 10599 | LogInfo("%s" , buffer); |
| 10600 | } |
| 10601 | } |
| 10602 | } |
| 10603 | } |
| 10604 | // Packet reception often causes a change to the task list: |
| 10605 | // 1. Inbound queries can cause us to need to send responses |
| 10606 | // 2. Conflicing response packets received from other hosts can cause us to need to send defensive responses |
| 10607 | // 3. Other hosts announcing deletion of shared records can cause us to need to re-assert those records |
| 10608 | // 4. Response packets that answer questions may cause our client to issue new questions |
| 10609 | mDNS_Unlock(m); |
| 10610 | } |
| 10611 | |
| 10612 | // *************************************************************************** |
| 10613 | #if COMPILER_LIKES_PRAGMA_MARK |
| 10614 | #pragma mark - |
| 10615 | #pragma mark - Searcher Functions |
| 10616 | #endif |
| 10617 | |
| 10618 | // Targets are considered the same if both queries are untargeted, or |
| 10619 | // if both are targeted to the same address+port |
| 10620 | // (If Target address is zero, TargetPort is undefined) |
| 10621 | #define SameQTarget(A,B) (((A)->Target.type == mDNSAddrType_None && (B)->Target.type == mDNSAddrType_None) || \ |
| 10622 | (mDNSSameAddress(& (A)->Target, & (B)->Target) && mDNSSameIPPort((A)->TargetPort, (B)->TargetPort))) |
| 10623 | |
| 10624 | // SameQuestionKind is true if *both* questions are either multicast or unicast |
| 10625 | // TargetQID is used for this determination. |
| 10626 | #define SameQuestionKind(A,B) ((mDNSOpaque16IsZero(A) && mDNSOpaque16IsZero(B)) || \ |
| 10627 | ((!mDNSOpaque16IsZero(A)) && (!mDNSOpaque16IsZero(B)))) |
| 10628 | |
| 10629 | // Note: We explicitly disallow making a public query be a duplicate of a private one. This is to avoid the |
| 10630 | // circular deadlock where a client does a query for something like "dns-sd -Q _dns-query-tls._tcp.company.com SRV" |
| 10631 | // and we have a key for company.com, so we try to locate the private query server for company.com, which necessarily entails |
| 10632 | // doing a standard DNS query for the _dns-query-tls._tcp SRV record for company.com. If we make the latter (public) query |
| 10633 | // a duplicate of the former (private) query, then it will block forever waiting for an answer that will never come. |
| 10634 | // |
| 10635 | // We keep SuppressUnusable questions separate so that we can return a quick response to them and not get blocked behind |
| 10636 | // the queries that are not marked SuppressUnusable. But if the query is not suppressed, they are treated the same as |
| 10637 | // non-SuppressUnusable questions. This should be fine as the goal of SuppressUnusable is to return quickly only if it |
| 10638 | // is suppressed. If it is not suppressed, we do try all the DNS servers for valid answers like any other question. |
| 10639 | // The main reason for this design is that cache entries point to a *single* question and that question is responsible |
| 10640 | // for keeping the cache fresh as long as it is active. Having multiple active question for a single cache entry |
| 10641 | // breaks this design principle. |
| 10642 | // |
| 10643 | |
| 10644 | // If IsLLQ(Q) is true, it means the question is both: |
| 10645 | // (a) long-lived and |
| 10646 | // (b) being performed by a unicast DNS long-lived query (either full LLQ, or polling) |
| 10647 | // for multicast questions, we don't want to treat LongLived as anything special |
| 10648 | #define IsLLQ(Q) ((Q)->LongLived && !mDNSOpaque16IsZero((Q)->TargetQID)) |
| 10649 | #define IsAWDLIncluded(Q) (((Q)->flags & kDNSServiceFlagsIncludeAWDL) != 0) |
| 10650 | |
| 10651 | mDNSlocal DNSQuestion *FindDuplicateQuestion(const mDNS *const m, const DNSQuestion *const question) |
| 10652 | { |
| 10653 | DNSQuestion *q; |
| 10654 | // Note: A question can only be marked as a duplicate of one that occurs *earlier* in the list. |
| 10655 | // This prevents circular references, where two questions are each marked as a duplicate of the other. |
| 10656 | // Accordingly, we break out of the loop when we get to 'question', because there's no point searching |
| 10657 | // further in the list. |
| 10658 | for (q = m->Questions; q && q != question; q=q->next) // Scan our list for another question |
| 10659 | if (q->InterfaceID == question->InterfaceID && // with the same InterfaceID, |
| 10660 | SameQTarget(q, question) && // and same unicast/multicast target settings |
| 10661 | q->qtype == question->qtype && // type, |
| 10662 | q->qclass == question->qclass && // class, |
| 10663 | IsLLQ(q) == IsLLQ(question) && // and long-lived status matches |
| 10664 | (!q->AuthInfo || question->AuthInfo) && // to avoid deadlock, don't make public query dup of a private one |
| 10665 | (q->AnonInfo == question->AnonInfo) && // Anonymous query not a dup of normal query |
| 10666 | (q->SuppressQuery == question->SuppressQuery) && // Questions that are suppressed/not suppressed |
| 10667 | (q->ValidationRequired == question->ValidationRequired) && // Questions that require DNSSEC validation |
| 10668 | (q->ValidatingResponse == question->ValidatingResponse) && // Questions that are validating responses using DNSSEC |
| 10669 | (q->DisallowPID == question->DisallowPID) && // Disallowing a PID should not affect a PID that is allowed |
| 10670 | (q->BrowseThreshold == question->BrowseThreshold) && // browse thresholds must match |
| 10671 | q->qnamehash == question->qnamehash && |
| 10672 | (IsAWDLIncluded(q) == IsAWDLIncluded(question)) && // Inclusion of AWDL interface must match |
| 10673 | SameQuestionKind(q->TargetQID, question->TargetQID) && // mDNS or uDNS must match |
| 10674 | SameDomainName(&q->qname, &question->qname)) // and name |
| 10675 | return(q); |
| 10676 | return(mDNSNULL); |
| 10677 | } |
| 10678 | |
| 10679 | // This is called after a question is deleted, in case other identical questions were being suppressed as duplicates |
| 10680 | mDNSlocal void UpdateQuestionDuplicates(mDNS *const m, DNSQuestion *const question) |
| 10681 | { |
| 10682 | DNSQuestion *q; |
| 10683 | DNSQuestion *first = mDNSNULL; |
| 10684 | |
| 10685 | // This is referring to some other question as duplicate. No other question can refer to this |
| 10686 | // question as a duplicate. |
| 10687 | if (question->DuplicateOf) |
| 10688 | { |
| 10689 | LogInfo("UpdateQuestionDuplicates: question %p %##s (%s) duplicate of %p %##s (%s)" , |
| 10690 | question, question->qname.c, DNSTypeName(question->qtype), |
| 10691 | question->DuplicateOf, question->DuplicateOf->qname.c, DNSTypeName(question->DuplicateOf->qtype)); |
| 10692 | return; |
| 10693 | } |
| 10694 | |
| 10695 | for (q = m->Questions; q; q=q->next) // Scan our list of questions |
| 10696 | if (q->DuplicateOf == question) // To see if any questions were referencing this as their duplicate |
| 10697 | { |
| 10698 | q->DuplicateOf = first; |
| 10699 | if (!first) |
| 10700 | { |
| 10701 | first = q; |
| 10702 | // If q used to be a duplicate, but now is not, |
| 10703 | // then inherit the state from the question that's going away |
| 10704 | q->LastQTime = question->LastQTime; |
| 10705 | q->ThisQInterval = question->ThisQInterval; |
| 10706 | q->ExpectUnicastResp = question->ExpectUnicastResp; |
| 10707 | q->LastAnswerPktNum = question->LastAnswerPktNum; |
| 10708 | q->RecentAnswerPkts = question->RecentAnswerPkts; |
| 10709 | q->RequestUnicast = question->RequestUnicast; |
| 10710 | q->LastQTxTime = question->LastQTxTime; |
| 10711 | q->CNAMEReferrals = question->CNAMEReferrals; |
| 10712 | q->nta = question->nta; |
| 10713 | q->servAddr = question->servAddr; |
| 10714 | q->servPort = question->servPort; |
| 10715 | q->qDNSServer = question->qDNSServer; |
| 10716 | q->validDNSServers = question->validDNSServers; |
| 10717 | q->unansweredQueries = question->unansweredQueries; |
| 10718 | q->noServerResponse = question->noServerResponse; |
| 10719 | q->triedAllServersOnce = question->triedAllServersOnce; |
| 10720 | |
| 10721 | q->TargetQID = question->TargetQID; |
| 10722 | q->LocalSocket = question->LocalSocket; |
| 10723 | // No need to close old q->LocalSocket first -- duplicate questions can't have their own sockets |
| 10724 | |
| 10725 | q->state = question->state; |
| 10726 | // q->tcp = question->tcp; |
| 10727 | q->ReqLease = question->ReqLease; |
| 10728 | q->expire = question->expire; |
| 10729 | q->ntries = question->ntries; |
| 10730 | q->id = question->id; |
| 10731 | |
| 10732 | question->LocalSocket = mDNSNULL; |
| 10733 | question->nta = mDNSNULL; // If we've got a GetZoneData in progress, transfer it to the newly active question |
| 10734 | // question->tcp = mDNSNULL; |
| 10735 | |
| 10736 | if (q->LocalSocket) |
| 10737 | debugf("UpdateQuestionDuplicates transferred LocalSocket pointer for %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 10738 | |
| 10739 | if (q->nta) |
| 10740 | { |
| 10741 | LogInfo("UpdateQuestionDuplicates transferred nta pointer for %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 10742 | q->nta->ZoneDataContext = q; |
| 10743 | } |
| 10744 | |
| 10745 | // Need to work out how to safely transfer this state too -- appropriate context pointers need to be updated or the code will crash |
| 10746 | if (question->tcp) LogInfo("UpdateQuestionDuplicates did not transfer tcp pointer" ); |
| 10747 | |
| 10748 | if (question->state == LLQ_Established) |
| 10749 | { |
| 10750 | LogInfo("UpdateQuestionDuplicates transferred LLQ state for %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 10751 | question->state = 0; // Must zero question->state, or mDNS_StopQuery_internal will clean up and cancel our LLQ from the server |
| 10752 | } |
| 10753 | |
| 10754 | SetNextQueryTime(m,q); |
| 10755 | } |
| 10756 | } |
| 10757 | } |
| 10758 | |
| 10759 | mDNSexport McastResolver *mDNS_AddMcastResolver(mDNS *const m, const domainname *d, const mDNSInterfaceID interface, mDNSu32 timeout) |
| 10760 | { |
| 10761 | McastResolver **p = &m->McastResolvers; |
| 10762 | McastResolver *tmp = mDNSNULL; |
| 10763 | |
| 10764 | if (!d) d = (const domainname *)"" ; |
| 10765 | |
| 10766 | LogInfo("mDNS_AddMcastResolver: Adding %##s, InterfaceID %p, timeout %u" , d->c, interface, timeout); |
| 10767 | |
| 10768 | mDNS_CheckLock(m); |
| 10769 | |
| 10770 | while (*p) // Check if we already have this {interface, domain} tuple registered |
| 10771 | { |
| 10772 | if ((*p)->interface == interface && SameDomainName(&(*p)->domain, d)) |
| 10773 | { |
| 10774 | if (!((*p)->flags & McastResolver_FlagDelete)) LogMsg("Note: Mcast Resolver domain %##s (%p) registered more than once" , d->c, interface); |
| 10775 | (*p)->flags &= ~McastResolver_FlagDelete; |
| 10776 | tmp = *p; |
| 10777 | *p = tmp->next; |
| 10778 | tmp->next = mDNSNULL; |
| 10779 | } |
| 10780 | else |
| 10781 | p=&(*p)->next; |
| 10782 | } |
| 10783 | |
| 10784 | if (tmp) *p = tmp; // move to end of list, to ensure ordering from platform layer |
| 10785 | else |
| 10786 | { |
| 10787 | // allocate, add to list |
| 10788 | *p = mDNSPlatformMemAllocate(sizeof(**p)); |
| 10789 | if (!*p) LogMsg("mDNS_AddMcastResolver: ERROR!! - malloc" ); |
| 10790 | else |
| 10791 | { |
| 10792 | (*p)->interface = interface; |
| 10793 | (*p)->flags = McastResolver_FlagNew; |
| 10794 | (*p)->timeout = timeout; |
| 10795 | AssignDomainName(&(*p)->domain, d); |
| 10796 | (*p)->next = mDNSNULL; |
| 10797 | } |
| 10798 | } |
| 10799 | return(*p); |
| 10800 | } |
| 10801 | |
| 10802 | mDNSinline mDNSs32 PenaltyTimeForServer(mDNS *m, DNSServer *server) |
| 10803 | { |
| 10804 | mDNSs32 ptime = 0; |
| 10805 | if (server->penaltyTime != 0) |
| 10806 | { |
| 10807 | ptime = server->penaltyTime - m->timenow; |
| 10808 | if (ptime < 0) |
| 10809 | { |
| 10810 | // This should always be a positive value between 0 and DNSSERVER_PENALTY_TIME |
| 10811 | // If it does not get reset in ResetDNSServerPenalties for some reason, we do it |
| 10812 | // here |
| 10813 | LogMsg("PenaltyTimeForServer: PenaltyTime negative %d, (server penaltyTime %d, timenow %d) resetting the penalty" , |
| 10814 | ptime, server->penaltyTime, m->timenow); |
| 10815 | server->penaltyTime = 0; |
| 10816 | ptime = 0; |
| 10817 | } |
| 10818 | } |
| 10819 | return ptime; |
| 10820 | } |
| 10821 | |
| 10822 | //Checks to see whether the newname is a better match for the name, given the best one we have |
| 10823 | //seen so far (given in bestcount). |
| 10824 | //Returns -1 if the newname is not a better match |
| 10825 | //Returns 0 if the newname is the same as the old match |
| 10826 | //Returns 1 if the newname is a better match |
| 10827 | mDNSlocal int BetterMatchForName(const domainname *name, int namecount, const domainname *newname, int newcount, |
| 10828 | int bestcount) |
| 10829 | { |
| 10830 | // If the name contains fewer labels than the new server's domain or the new name |
| 10831 | // contains fewer labels than the current best, then it can't possibly be a better match |
| 10832 | if (namecount < newcount || newcount < bestcount) return -1; |
| 10833 | |
| 10834 | // If there is no match, return -1 and the caller will skip this newname for |
| 10835 | // selection |
| 10836 | // |
| 10837 | // If we find a match and the number of labels is the same as bestcount, then |
| 10838 | // we return 0 so that the caller can do additional logic to pick one of |
| 10839 | // the best based on some other factors e.g., penaltyTime |
| 10840 | // |
| 10841 | // If we find a match and the number of labels is more than bestcount, then we |
| 10842 | // return 1 so that the caller can pick this over the old one. |
| 10843 | // |
| 10844 | // Note: newcount can either be equal or greater than bestcount beause of the |
| 10845 | // check above. |
| 10846 | |
| 10847 | if (SameDomainName(SkipLeadingLabels(name, namecount - newcount), newname)) |
| 10848 | return bestcount == newcount ? 0 : 1; |
| 10849 | else |
| 10850 | return -1; |
| 10851 | } |
| 10852 | |
| 10853 | // Normally, we have McastResolvers for .local, in-addr.arpa and ip6.arpa. But there |
| 10854 | // can be queries that can forced to multicast (ForceMCast) even though they don't end in these |
| 10855 | // names. In that case, we give a default timeout of 5 seconds |
| 10856 | #define DEFAULT_MCAST_TIMEOUT 5 |
| 10857 | mDNSlocal mDNSu32 GetTimeoutForMcastQuestion(mDNS *m, DNSQuestion *question) |
| 10858 | { |
| 10859 | McastResolver *curmatch = mDNSNULL; |
| 10860 | int bestmatchlen = -1, namecount = CountLabels(&question->qname); |
| 10861 | McastResolver *curr; |
| 10862 | int bettermatch, currcount; |
| 10863 | for (curr = m->McastResolvers; curr; curr = curr->next) |
| 10864 | { |
| 10865 | currcount = CountLabels(&curr->domain); |
| 10866 | bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen); |
| 10867 | // Take the first best match. If there are multiple equally good matches (bettermatch = 0), we take |
| 10868 | // the timeout value from the first one |
| 10869 | if (bettermatch == 1) |
| 10870 | { |
| 10871 | curmatch = curr; |
| 10872 | bestmatchlen = currcount; |
| 10873 | } |
| 10874 | } |
| 10875 | LogInfo("GetTimeoutForMcastQuestion: question %##s curmatch %p, Timeout %d" , question->qname.c, curmatch, |
| 10876 | curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT); |
| 10877 | return ( curmatch ? curmatch->timeout : DEFAULT_MCAST_TIMEOUT); |
| 10878 | } |
| 10879 | |
| 10880 | // Returns true if it is a Domain Enumeration Query |
| 10881 | mDNSexport mDNSBool DomainEnumQuery(const domainname *qname) |
| 10882 | { |
| 10883 | const mDNSu8 *mDNS_DEQLabels[] = { (const mDNSu8 *)"\001b" , (const mDNSu8 *)"\002db" , (const mDNSu8 *)"\002lb" , |
| 10884 | (const mDNSu8 *)"\001r" , (const mDNSu8 *)"\002dr" , (const mDNSu8 *)mDNSNULL, }; |
| 10885 | const domainname *d = qname; |
| 10886 | const mDNSu8 *label; |
| 10887 | int i = 0; |
| 10888 | |
| 10889 | // We need at least 3 labels (DEQ prefix) + one more label to make a meaningful DE query |
| 10890 | if (CountLabels(qname) < 4) { debugf("DomainEnumQuery: question %##s, not enough labels" , qname->c); return mDNSfalse; } |
| 10891 | |
| 10892 | label = (const mDNSu8 *)d; |
| 10893 | while (mDNS_DEQLabels[i] != (const mDNSu8 *)mDNSNULL) |
| 10894 | { |
| 10895 | if (SameDomainLabel(mDNS_DEQLabels[i], label)) {debugf("DomainEnumQuery: DEQ %##s, label1 match" , qname->c); break;} |
| 10896 | i++; |
| 10897 | } |
| 10898 | if (mDNS_DEQLabels[i] == (const mDNSu8 *)mDNSNULL) |
| 10899 | { |
| 10900 | debugf("DomainEnumQuery: Not a DEQ %##s, label1 mismatch" , qname->c); |
| 10901 | return mDNSfalse; |
| 10902 | } |
| 10903 | debugf("DomainEnumQuery: DEQ %##s, label1 match" , qname->c); |
| 10904 | |
| 10905 | // CountLabels already verified the number of labels |
| 10906 | d = (const domainname *)(d->c + 1 + d->c[0]); // Second Label |
| 10907 | label = (const mDNSu8 *)d; |
| 10908 | if (!SameDomainLabel(label, (const mDNSu8 *)"\007_dns-sd" )) |
| 10909 | { |
| 10910 | debugf("DomainEnumQuery: Not a DEQ %##s, label2 mismatch" , qname->c); |
| 10911 | return(mDNSfalse); |
| 10912 | } |
| 10913 | debugf("DomainEnumQuery: DEQ %##s, label2 match" , qname->c); |
| 10914 | |
| 10915 | d = (const domainname *)(d->c + 1 + d->c[0]); // Third Label |
| 10916 | label = (const mDNSu8 *)d; |
| 10917 | if (!SameDomainLabel(label, (const mDNSu8 *)"\004_udp" )) |
| 10918 | { |
| 10919 | debugf("DomainEnumQuery: Not a DEQ %##s, label3 mismatch" , qname->c); |
| 10920 | return(mDNSfalse); |
| 10921 | } |
| 10922 | debugf("DomainEnumQuery: DEQ %##s, label3 match" , qname->c); |
| 10923 | |
| 10924 | debugf("DomainEnumQuery: Question %##s is a Domain Enumeration query" , qname->c); |
| 10925 | |
| 10926 | return mDNStrue; |
| 10927 | } |
| 10928 | |
| 10929 | // Note: InterfaceID is the InterfaceID of the question |
| 10930 | mDNSlocal mDNSBool DNSServerMatch(DNSServer *d, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID) |
| 10931 | { |
| 10932 | // 1) Unscoped questions (NULL InterfaceID) should consider *only* unscoped DNSServers ( DNSServer |
| 10933 | // with "scoped" set to kScopeNone) |
| 10934 | // |
| 10935 | // 2) Scoped questions (non-NULL InterfaceID) should consider *only* scoped DNSServers (DNSServer |
| 10936 | // with "scoped" set to kScopeInterfaceId) and their InterfaceIDs should match. |
| 10937 | // |
| 10938 | // 3) Scoped questions (non-zero ServiceID) should consider *only* scoped DNSServers (DNSServer |
| 10939 | // with "scoped" set to kScopeServiceID) and their ServiceIDs should match. |
| 10940 | // |
| 10941 | // The first condition in the "if" statement checks to see if both the question and the DNSServer are |
| 10942 | // unscoped. The question is unscoped only if InterfaceID is zero and ServiceID is -1. |
| 10943 | // |
| 10944 | // If the first condition fails, following are the possible cases (the notes below are using |
| 10945 | // InterfaceID for discussion and the same holds good for ServiceID): |
| 10946 | // |
| 10947 | // - DNSServer is not scoped, InterfaceID is not NULL - we should skip the current DNSServer entry |
| 10948 | // as scoped questions should not pick non-scoped DNSServer entry (Refer to (2) above). |
| 10949 | // |
| 10950 | // - DNSServer is scoped, InterfaceID is NULL - we should skip the current DNSServer entry as |
| 10951 | // unscoped question should not match scoped DNSServer (Refer to (1) above). The InterfaceID check |
| 10952 | // would fail in this case. |
| 10953 | // |
| 10954 | // - DNSServer is scoped and InterfaceID is not NULL - the InterfaceID of the question and the DNSServer |
| 10955 | // should match (Refer to (2) above). |
| 10956 | // |
| 10957 | // Note: mDNSInterface_Unicast is used only by .local unicast questions and are treated as unscoped. |
| 10958 | // If a question is scoped both to InterfaceID and ServiceID, the question will be scoped to InterfaceID. |
| 10959 | |
| 10960 | if (((d->scoped == kScopeNone) && ((!InterfaceID && ServiceID == -1) || InterfaceID == mDNSInterface_Unicast)) || |
| 10961 | ((d->scoped == kScopeInterfaceID) && d->interface == InterfaceID) || |
| 10962 | ((d->scoped == kScopeServiceID) && d->serviceID == ServiceID)) |
| 10963 | { |
| 10964 | return mDNStrue; |
| 10965 | } |
| 10966 | return mDNSfalse; |
| 10967 | } |
| 10968 | |
| 10969 | // Sets all the Valid DNS servers for a question |
| 10970 | mDNSexport mDNSu32 SetValidDNSServers(mDNS *m, DNSQuestion *question) |
| 10971 | { |
| 10972 | int bestmatchlen = -1, namecount = CountLabels(&question->qname); |
| 10973 | DNSServer *curr; |
| 10974 | int bettermatch, currcount; |
| 10975 | int index = 0; |
| 10976 | mDNSu32 timeout = 0; |
| 10977 | mDNSBool DEQuery; |
| 10978 | |
| 10979 | question->validDNSServers = zeroOpaque128; |
| 10980 | DEQuery = DomainEnumQuery(&question->qname); |
| 10981 | for (curr = m->DNSServers; curr; curr = curr->next) |
| 10982 | { |
| 10983 | debugf("SetValidDNSServers: Parsing DNS server Address %#a (Domain %##s), Scope: %d" , &curr->addr, curr->domain.c, curr->scoped); |
| 10984 | // skip servers that will soon be deleted |
| 10985 | if (curr->flags & DNSServer_FlagDelete) |
| 10986 | { |
| 10987 | debugf("SetValidDNSServers: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d" , index, &curr->addr, curr->domain.c, curr->scoped); |
| 10988 | continue; |
| 10989 | } |
| 10990 | |
| 10991 | // This happens normally when you unplug the interface where we reset the interfaceID to mDNSInterface_Any for all |
| 10992 | // the DNS servers whose scope match the interfaceID. Few seconds later, we also receive the updated DNS configuration. |
| 10993 | // But any questions that has mDNSInterface_Any scope that are started/restarted before we receive the update |
| 10994 | // (e.g., CheckSuppressUnusableQuestions is called when interfaces are deregistered with the core) should not |
| 10995 | // match the scoped entries by mistake. |
| 10996 | // |
| 10997 | // Note: DNS configuration change will help pick the new dns servers but currently it does not affect the timeout |
| 10998 | |
| 10999 | // Skip DNSServers that are InterfaceID Scoped but have no valid interfaceid set OR DNSServers that are ServiceID Scoped but have no valid serviceid set |
| 11000 | if ((curr->scoped == kScopeInterfaceID && curr->interface == mDNSInterface_Any) || (curr->scoped == kScopeServiceID && curr->serviceID <= 0)) |
| 11001 | { |
| 11002 | LogInfo("SetValidDNSServers: ScopeType[%d] Skipping DNS server %#a (Domain %##s) Interface:[%p] Serviceid:[%d]" , curr->scoped, &curr->addr, curr->domain.c, curr->interface, curr->serviceID); |
| 11003 | continue; |
| 11004 | } |
| 11005 | |
| 11006 | currcount = CountLabels(&curr->domain); |
| 11007 | if ((!curr->cellIntf || (!DEQuery && !(question->flags & kDNSServiceFlagsDenyCellular))) && |
| 11008 | (!curr->isExpensive || !(question->flags & kDNSServiceFlagsDenyExpensive)) && |
| 11009 | DNSServerMatch(curr, question->InterfaceID, question->ServiceID)) |
| 11010 | { |
| 11011 | bettermatch = BetterMatchForName(&question->qname, namecount, &curr->domain, currcount, bestmatchlen); |
| 11012 | |
| 11013 | // If we found a better match (bettermatch == 1) then clear all the bits |
| 11014 | // corresponding to the old DNSServers that we have may set before and start fresh. |
| 11015 | // If we find an equal match, then include that DNSServer also by setting the corresponding |
| 11016 | // bit |
| 11017 | if ((bettermatch == 1) || (bettermatch == 0)) |
| 11018 | { |
| 11019 | bestmatchlen = currcount; |
| 11020 | if (bettermatch) |
| 11021 | { |
| 11022 | debugf("SetValidDNSServers: Resetting all the bits" ); |
| 11023 | question->validDNSServers = zeroOpaque128; |
| 11024 | timeout = 0; |
| 11025 | } |
| 11026 | debugf("SetValidDNSServers: question %##s Setting the bit for DNS server Address %#a (Domain %##s), Scoped:%d index %d," |
| 11027 | " Timeout %d, interface %p" , question->qname.c, &curr->addr, curr->domain.c, curr->scoped, index, curr->timeout, |
| 11028 | curr->interface); |
| 11029 | timeout += curr->timeout; |
| 11030 | if (DEQuery) |
| 11031 | debugf("DomainEnumQuery: Question %##s, DNSServer %#a, cell %d" , question->qname.c, &curr->addr, curr->cellIntf); |
| 11032 | bit_set_opaque128(question->validDNSServers, index); |
| 11033 | } |
| 11034 | } |
| 11035 | index++; |
| 11036 | } |
| 11037 | question->noServerResponse = 0; |
| 11038 | |
| 11039 | debugf("SetValidDNSServers: ValidDNSServer bits 0x%x%x%x%x for question %p %##s (%s)" , |
| 11040 | question->validDNSServers.l[3], question->validDNSServers.l[2], question->validDNSServers.l[1], question->validDNSServers.l[0], question, question->qname.c, DNSTypeName(question->qtype)); |
| 11041 | // If there are no matching resolvers, then use the default timeout value. |
| 11042 | // For ProxyQuestion, shorten the timeout so that dig does not timeout on us in case of no response. |
| 11043 | return ((question->ProxyQuestion || question->ValidatingResponse) ? DEFAULT_UDNSSEC_TIMEOUT : timeout ? timeout : DEFAULT_UDNS_TIMEOUT); |
| 11044 | } |
| 11045 | |
| 11046 | // Get the Best server that matches a name. If you find penalized servers, look for the one |
| 11047 | // that will come out of the penalty box soon |
| 11048 | mDNSlocal DNSServer *GetBestServer(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID, mDNSOpaque128 validBits, |
| 11049 | int *selected, mDNSBool nameMatch) |
| 11050 | { |
| 11051 | DNSServer *curmatch = mDNSNULL; |
| 11052 | int bestmatchlen = -1, namecount = name ? CountLabels(name) : 0; |
| 11053 | DNSServer *curr; |
| 11054 | mDNSs32 bestPenaltyTime, currPenaltyTime; |
| 11055 | int bettermatch, currcount; |
| 11056 | int index = 0; |
| 11057 | int currindex = -1; |
| 11058 | |
| 11059 | debugf("GetBestServer: ValidDNSServer bits 0x%x%x" , validBits.l[1], validBits.l[0]); |
| 11060 | bestPenaltyTime = DNSSERVER_PENALTY_TIME + 1; |
| 11061 | for (curr = m->DNSServers; curr; curr = curr->next) |
| 11062 | { |
| 11063 | // skip servers that will soon be deleted |
| 11064 | if (curr->flags & DNSServer_FlagDelete) |
| 11065 | { |
| 11066 | debugf("GetBestServer: Delete set for index %d, DNS server %#a (Domain %##s), scoped %d" , index, &curr->addr, curr->domain.c, curr->scoped); |
| 11067 | continue; |
| 11068 | } |
| 11069 | |
| 11070 | // Check if this is a valid DNSServer |
| 11071 | if (!bit_get_opaque64(validBits, index)) |
| 11072 | { |
| 11073 | debugf("GetBestServer: continuing for index %d" , index); |
| 11074 | index++; |
| 11075 | continue; |
| 11076 | } |
| 11077 | |
| 11078 | currcount = CountLabels(&curr->domain); |
| 11079 | currPenaltyTime = PenaltyTimeForServer(m, curr); |
| 11080 | |
| 11081 | debugf("GetBestServer: Address %#a (Domain %##s), PenaltyTime(abs) %d, PenaltyTime(rel) %d" , |
| 11082 | &curr->addr, curr->domain.c, curr->penaltyTime, currPenaltyTime); |
| 11083 | |
| 11084 | // If there are multiple best servers for a given question, we will pick the first one |
| 11085 | // if none of them are penalized. If some of them are penalized in that list, we pick |
| 11086 | // the least penalized one. BetterMatchForName walks through all best matches and |
| 11087 | // "currPenaltyTime < bestPenaltyTime" check lets us either pick the first best server |
| 11088 | // in the list when there are no penalized servers and least one among them |
| 11089 | // when there are some penalized servers. |
| 11090 | |
| 11091 | if (DNSServerMatch(curr, InterfaceID, ServiceID)) |
| 11092 | { |
| 11093 | |
| 11094 | // If we know that all the names are already equally good matches, then skip calling BetterMatchForName. |
| 11095 | // This happens when we initially walk all the DNS servers and set the validity bit on the question. |
| 11096 | // Actually we just need PenaltyTime match, but for the sake of readability we just skip the expensive |
| 11097 | // part and still do some redundant steps e.g., InterfaceID match |
| 11098 | |
| 11099 | if (nameMatch) |
| 11100 | bettermatch = BetterMatchForName(name, namecount, &curr->domain, currcount, bestmatchlen); |
| 11101 | else |
| 11102 | bettermatch = 0; |
| 11103 | |
| 11104 | // If we found a better match (bettermatch == 1) then we don't need to |
| 11105 | // compare penalty times. But if we found an equal match, then we compare |
| 11106 | // the penalty times to pick a better match |
| 11107 | |
| 11108 | if ((bettermatch == 1) || ((bettermatch == 0) && currPenaltyTime < bestPenaltyTime)) |
| 11109 | { |
| 11110 | currindex = index; |
| 11111 | curmatch = curr; |
| 11112 | bestmatchlen = currcount; |
| 11113 | bestPenaltyTime = currPenaltyTime; |
| 11114 | } |
| 11115 | } |
| 11116 | index++; |
| 11117 | } |
| 11118 | if (selected) *selected = currindex; |
| 11119 | return curmatch; |
| 11120 | } |
| 11121 | |
| 11122 | // Look up a DNS Server, matching by name and InterfaceID |
| 11123 | mDNSlocal DNSServer *GetServerForName(mDNS *m, const domainname *name, mDNSInterfaceID InterfaceID, mDNSs32 ServiceID) |
| 11124 | { |
| 11125 | DNSServer *curmatch = mDNSNULL; |
| 11126 | char *ifname = mDNSNULL; // for logging purposes only |
| 11127 | mDNSOpaque128 allValid; |
| 11128 | |
| 11129 | if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly)) |
| 11130 | InterfaceID = mDNSNULL; |
| 11131 | |
| 11132 | if (InterfaceID) ifname = InterfaceNameForID(m, InterfaceID); |
| 11133 | |
| 11134 | // By passing in all ones, we make sure that every DNS server is considered |
| 11135 | allValid.l[0] = allValid.l[1] = allValid.l[2] = allValid.l[3] = 0xFFFFFFFF; |
| 11136 | |
| 11137 | curmatch = GetBestServer(m, name, InterfaceID, ServiceID, allValid, mDNSNULL, mDNStrue); |
| 11138 | |
| 11139 | if (curmatch != mDNSNULL) |
| 11140 | LogInfo("GetServerForName: DNS server %#a:%d (Penalty Time Left %d) (Scope %s:%p) found for name %##s" , &curmatch->addr, |
| 11141 | mDNSVal16(curmatch->port), (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None" , |
| 11142 | InterfaceID, name); |
| 11143 | else |
| 11144 | LogInfo("GetServerForName: no DNS server (Scope %s:%p) found for name %##s" , ifname ? ifname : "None" , InterfaceID, name); |
| 11145 | |
| 11146 | return(curmatch); |
| 11147 | } |
| 11148 | |
| 11149 | // Look up a DNS Server for a question within its valid DNSServer bits |
| 11150 | mDNSexport DNSServer *GetServerForQuestion(mDNS *m, DNSQuestion *question) |
| 11151 | { |
| 11152 | DNSServer *curmatch = mDNSNULL; |
| 11153 | char *ifname = mDNSNULL; // for logging purposes only |
| 11154 | mDNSInterfaceID InterfaceID = question->InterfaceID; |
| 11155 | const domainname *name = &question->qname; |
| 11156 | int currindex; |
| 11157 | |
| 11158 | if ((InterfaceID == mDNSInterface_Unicast) || (InterfaceID == mDNSInterface_LocalOnly)) |
| 11159 | InterfaceID = mDNSNULL; |
| 11160 | |
| 11161 | if (InterfaceID) |
| 11162 | ifname = InterfaceNameForID(m, InterfaceID); |
| 11163 | |
| 11164 | if (!mDNSOpaque128IsZero(&question->validDNSServers)) |
| 11165 | { |
| 11166 | curmatch = GetBestServer(m, name, InterfaceID, question->ServiceID, question->validDNSServers, &currindex, mDNSfalse); |
| 11167 | if (currindex != -1) |
| 11168 | bit_clr_opaque128(question->validDNSServers, currindex); |
| 11169 | } |
| 11170 | |
| 11171 | if (curmatch != mDNSNULL) |
| 11172 | { |
| 11173 | LogInfo("GetServerForQuestion: %p DNS server (%p) %#a:%d (Penalty Time Left %d) (Scope %s:%p:%d) found for name %##s (%s)" , |
| 11174 | question, curmatch, &curmatch->addr, mDNSVal16(curmatch->port), |
| 11175 | (curmatch->penaltyTime ? (curmatch->penaltyTime - m->timenow) : 0), ifname ? ifname : "None" , |
| 11176 | InterfaceID, question->ServiceID, name, DNSTypeName(question->qtype)); |
| 11177 | } |
| 11178 | else |
| 11179 | { |
| 11180 | LogInfo("GetServerForQuestion: %p no DNS server (Scope %s:%p:%d) found for name %##s (%s)" , |
| 11181 | question, ifname ? ifname : "None" , InterfaceID, question->ServiceID, name, DNSTypeName(question->qtype)); |
| 11182 | } |
| 11183 | |
| 11184 | return(curmatch); |
| 11185 | } |
| 11186 | |
| 11187 | |
| 11188 | #define ValidQuestionTarget(Q) (((Q)->Target.type == mDNSAddrType_IPv4 || (Q)->Target.type == mDNSAddrType_IPv6) && \ |
| 11189 | (mDNSSameIPPort((Q)->TargetPort, UnicastDNSPort) || mDNSSameIPPort((Q)->TargetPort, MulticastDNSPort))) |
| 11190 | |
| 11191 | // Called in normal client context (lock not held) |
| 11192 | mDNSlocal void LLQNATCallback(mDNS *m, NATTraversalInfo *n) |
| 11193 | { |
| 11194 | DNSQuestion *q; |
| 11195 | mDNS_Lock(m); |
| 11196 | LogInfo("LLQNATCallback external address:port %.4a:%u, NAT result %d" , &n->ExternalAddress, mDNSVal16(n->ExternalPort), n->Result); |
| 11197 | n->clientContext = mDNSNULL; // we received at least one callback since starting this NAT-T |
| 11198 | for (q = m->Questions; q; q=q->next) |
| 11199 | if (ActiveQuestion(q) && !mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) |
| 11200 | startLLQHandshake(m, q); // If ExternalPort is zero, will do StartLLQPolling instead |
| 11201 | #if APPLE_OSX_mDNSResponder |
| 11202 | UpdateAutoTunnelDomainStatuses(m); |
| 11203 | #endif |
| 11204 | mDNS_Unlock(m); |
| 11205 | } |
| 11206 | |
| 11207 | mDNSlocal mDNSBool IsPrivateDomain(mDNS *const m, DNSQuestion *q) |
| 11208 | { |
| 11209 | DomainAuthInfo *AuthInfo; |
| 11210 | // Skip Private domains as we have special addresses to get the hosts in the Private domain |
| 11211 | AuthInfo = GetAuthInfoForName_internal(m, &q->qname); |
| 11212 | if (AuthInfo && !AuthInfo->deltime && AuthInfo->AutoTunnel) |
| 11213 | { |
| 11214 | debugf("IsPrivateDomain: %##s true" , q->qname.c); |
| 11215 | return mDNStrue; |
| 11216 | } |
| 11217 | else |
| 11218 | { |
| 11219 | debugf("IsPrivateDomain: %##s false" , q->qname.c); |
| 11220 | return mDNSfalse; |
| 11221 | } |
| 11222 | } |
| 11223 | |
| 11224 | // This function takes the DNSServer as a separate argument because sometimes the |
| 11225 | // caller has not yet assigned the DNSServer, but wants to evaluate the SuppressQuery |
| 11226 | // status before switching to it. |
| 11227 | mDNSlocal mDNSBool ShouldSuppressUnicastQuery(mDNS *const m, DNSQuestion *q, DNSServer *d) |
| 11228 | { |
| 11229 | // Some callers don't check for the qtype |
| 11230 | if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA) |
| 11231 | { |
| 11232 | LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type" , q->qname.c, DNSTypeName(q->qtype)); |
| 11233 | return mDNSfalse; |
| 11234 | } |
| 11235 | |
| 11236 | // Private domains are exempted irrespective of what the DNSServer says |
| 11237 | if (IsPrivateDomain(m, q)) |
| 11238 | { |
| 11239 | LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, Private Domain" , q->qname.c, DNSTypeName(q->qtype)); |
| 11240 | return mDNSfalse; |
| 11241 | } |
| 11242 | |
| 11243 | if (!d) |
| 11244 | { |
| 11245 | LogInfo("ShouldSuppressUnicastQuery: Query suppressed for %##s, qtype %s, as the DNS server is NULL" , q->qname.c, DNSTypeName(q->qtype)); |
| 11246 | return mDNStrue; |
| 11247 | } |
| 11248 | |
| 11249 | // Check if the DNS Configuration allows A/AAAA queries to be sent |
| 11250 | if ((q->qtype == kDNSType_A) && (d->req_A)) |
| 11251 | { |
| 11252 | LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, DNSServer %##s %#a:%d allows A queries" , q->qname.c, |
| 11253 | DNSTypeName(q->qtype), d->domain.c, &d->addr, mDNSVal16(d->port)); |
| 11254 | return mDNSfalse; |
| 11255 | } |
| 11256 | if ((q->qtype == kDNSType_AAAA) && (d->req_AAAA)) |
| 11257 | { |
| 11258 | LogInfo("ShouldSuppressUnicastQuery: Query not suppressed for %##s, qtype %s, DNSServer %##s %#a:%d allows AAAA queries" , q->qname.c, |
| 11259 | DNSTypeName(q->qtype), d->domain.c, &d->addr, mDNSVal16(d->port)); |
| 11260 | return mDNSfalse; |
| 11261 | } |
| 11262 | #if USE_DNS64 |
| 11263 | if (DNS64IsQueryingARecord(q->dns64.state)) |
| 11264 | { |
| 11265 | LogInfo("ShouldSuppressUnicastQuery: DNS64 query not suppressed for %##s, qtype %s" , q->qname.c, DNSTypeName(q->qtype)); |
| 11266 | return mDNSfalse; |
| 11267 | } |
| 11268 | #endif |
| 11269 | |
| 11270 | LogInfo("ShouldSuppressUnicastQuery: Query suppressed for %##s, qtype %s, since DNS Configuration does not allow (req_A is %s and req_AAAA is %s)" , |
| 11271 | q->qname.c, DNSTypeName(q->qtype), d->req_A ? "true" : "false" , d->req_AAAA ? "true" : "false" ); |
| 11272 | |
| 11273 | return mDNStrue; |
| 11274 | } |
| 11275 | |
| 11276 | mDNSlocal mDNSBool ShouldSuppressDotLocalQuery(mDNS *const m, DNSQuestion *q) |
| 11277 | { |
| 11278 | NetworkInterfaceInfo *intf; |
| 11279 | AuthRecord *rr; |
| 11280 | mDNSBool ret; |
| 11281 | |
| 11282 | // Check to see if there is at least one interface other than loopback and don't suppress |
| 11283 | // .local questions if you find one. If we have at least one interface, it means that |
| 11284 | // we can send unicast queries for the .local name and we don't want to suppress |
| 11285 | // multicast in that case as upper layers don't know how to handle if we return a |
| 11286 | // negative response for multicast followed by a positive response for unicast. |
| 11287 | // |
| 11288 | // Note: we used to check for multicast capable interfaces instead of just any interface |
| 11289 | // present. That did not work in the case where we have a valid interface for unicast |
| 11290 | // but not multicast capable e.g., cellular, as we ended up delivering a negative response |
| 11291 | // first and the upper layer did not wait for the positive response that came later. |
| 11292 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 11293 | { |
| 11294 | if (intf->InterfaceActive && !intf->Loopback) |
| 11295 | { |
| 11296 | LogInfo("ShouldSuppressDotLocalQuery: Found interface %s, not suppressing" , intf->ifname); |
| 11297 | return mDNSfalse; |
| 11298 | } |
| 11299 | } |
| 11300 | |
| 11301 | // 1. If we find a LocalOnly or P2P record answering this question, then don't suppress it. |
| 11302 | // Set m->CurrentQuestion as it is required by AnswerQuestionWithLORecord. |
| 11303 | m->CurrentQuestion = q; |
| 11304 | ret = AnswerQuestionWithLORecord(m, q, mDNStrue); |
| 11305 | m->CurrentQuestion = mDNSNULL; |
| 11306 | |
| 11307 | if (ret) |
| 11308 | { |
| 11309 | LogInfo("ShouldSuppressDotLocalQuery: Found LocalOnly record for %##s (%s), not suppressing" , q->qname.c, |
| 11310 | DNSTypeName(q->qtype)); |
| 11311 | return mDNSfalse; |
| 11312 | } |
| 11313 | |
| 11314 | // 2. If we find a local AuthRecord answering this question, then don't suppress it. |
| 11315 | for (rr = m->ResourceRecords; rr; rr = rr->next) |
| 11316 | { |
| 11317 | if (ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 11318 | { |
| 11319 | LogInfo("ShouldSuppressDotLocalQuery: Found resource record %s for %##s (%s) not suppressing" , ARDisplayString(m, rr), |
| 11320 | q->qname.c, DNSTypeName(q->qtype)); |
| 11321 | return mDNSfalse; |
| 11322 | } |
| 11323 | } |
| 11324 | return mDNStrue; |
| 11325 | } |
| 11326 | |
| 11327 | mDNSlocal mDNSBool ShouldSuppressQuery(mDNS *const m, DNSQuestion *q) |
| 11328 | { |
| 11329 | if (q->InterfaceID == mDNSInterface_LocalOnly) |
| 11330 | { |
| 11331 | LogInfo("ShouldSuppressQuery: LocalOnly query not suppressed for %##s, qtype %s" , q->qname.c, DNSTypeName(q->qtype)); |
| 11332 | return mDNSfalse; |
| 11333 | } |
| 11334 | |
| 11335 | if (q->qtype != kDNSType_A && q->qtype != kDNSType_AAAA) |
| 11336 | { |
| 11337 | LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, not A/AAAA type" , q->qname.c, DNSTypeName(q->qtype)); |
| 11338 | return mDNSfalse; |
| 11339 | } |
| 11340 | |
| 11341 | // We still want the ability to be able to listen to the local services and hence |
| 11342 | // don't fail .local query if we have local records that can potentially answer |
| 11343 | // the question. |
| 11344 | if (q->InterfaceID != mDNSInterface_Unicast && IsLocalDomain(&q->qname)) |
| 11345 | { |
| 11346 | if (!ShouldSuppressDotLocalQuery(m, q)) |
| 11347 | { |
| 11348 | LogInfo("ShouldSuppressQuery: Query not suppressed for %##s, qtype %s, Local question" , q->qname.c, DNSTypeName(q->qtype)); |
| 11349 | return mDNSfalse; |
| 11350 | } |
| 11351 | else |
| 11352 | { |
| 11353 | LogInfo("ShouldSuppressQuery: Query suppressed for %##s, qtype %s, Local question" , q->qname.c, DNSTypeName(q->qtype)); |
| 11354 | return mDNStrue; |
| 11355 | } |
| 11356 | } |
| 11357 | |
| 11358 | return (ShouldSuppressUnicastQuery(m, q, q->qDNSServer)); |
| 11359 | } |
| 11360 | |
| 11361 | mDNSlocal void CacheRecordRmvEventsForCurrentQuestion(mDNS *const m, DNSQuestion *q) |
| 11362 | { |
| 11363 | CacheRecord *rr; |
| 11364 | CacheGroup *cg; |
| 11365 | |
| 11366 | cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 11367 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 11368 | { |
| 11369 | // Don't deliver RMV events for negative records |
| 11370 | if (rr->resrec.RecordType == kDNSRecordTypePacketNegative) |
| 11371 | { |
| 11372 | LogInfo("CacheRecordRmvEventsForCurrentQuestion: CacheRecord %s Suppressing RMV events for question %p %##s (%s), CRActiveQuestion %p, CurrentAnswers %d" , |
| 11373 | CRDisplayString(m, rr), q, q->qname.c, DNSTypeName(q->qtype), rr->CRActiveQuestion, q->CurrentAnswers); |
| 11374 | continue; |
| 11375 | } |
| 11376 | |
| 11377 | if (SameNameRecordAnswersQuestion(&rr->resrec, q)) |
| 11378 | { |
| 11379 | LogInfo("CacheRecordRmvEventsForCurrentQuestion: Calling AnswerCurrentQuestionWithResourceRecord (RMV) for question %##s using resource record %s LocalAnswers %d" , |
| 11380 | q->qname.c, CRDisplayString(m, rr), q->LOAddressAnswers); |
| 11381 | |
| 11382 | q->CurrentAnswers--; |
| 11383 | if (rr->resrec.rdlength > SmallRecordLimit) q->LargeAnswers--; |
| 11384 | if (rr->resrec.RecordType & kDNSRecordTypePacketUniqueMask) q->UniqueAnswers--; |
| 11385 | |
| 11386 | if (rr->CRActiveQuestion == q) |
| 11387 | { |
| 11388 | DNSQuestion *qptr; |
| 11389 | // If this was the active question for this cache entry, it was the one that was |
| 11390 | // responsible for keeping the cache entry fresh when the cache entry was reaching |
| 11391 | // its expiry. We need to handover the responsibility to someone else. Otherwise, |
| 11392 | // when the cache entry is about to expire, we won't find an active question |
| 11393 | // (pointed by CRActiveQuestion) to refresh the cache. |
| 11394 | for (qptr = m->Questions; qptr; qptr=qptr->next) |
| 11395 | if (qptr != q && ActiveQuestion(qptr) && ResourceRecordAnswersQuestion(&rr->resrec, qptr)) |
| 11396 | break; |
| 11397 | |
| 11398 | if (qptr) |
| 11399 | LogInfo("CacheRecordRmvEventsForCurrentQuestion: Updating CRActiveQuestion to %p for cache record %s, " |
| 11400 | "Original question CurrentAnswers %d, new question CurrentAnswers %d, SuppressUnusable %d, SuppressQuery %d" , |
| 11401 | qptr, CRDisplayString(m,rr), q->CurrentAnswers, qptr->CurrentAnswers, qptr->SuppressUnusable, qptr->SuppressQuery); |
| 11402 | |
| 11403 | rr->CRActiveQuestion = qptr; // Question used to be active; new value may or may not be null |
| 11404 | if (!qptr) m->rrcache_active--; // If no longer active, decrement rrcache_active count |
| 11405 | } |
| 11406 | AnswerCurrentQuestionWithResourceRecord(m, rr, QC_rmv); |
| 11407 | if (m->CurrentQuestion != q) break; // If callback deleted q, then we're finished here |
| 11408 | } |
| 11409 | } |
| 11410 | } |
| 11411 | |
| 11412 | mDNSlocal mDNSBool IsQuestionNew(mDNS *const m, DNSQuestion *question) |
| 11413 | { |
| 11414 | DNSQuestion *q; |
| 11415 | for (q = m->NewQuestions; q; q = q->next) |
| 11416 | if (q == question) return mDNStrue; |
| 11417 | return mDNSfalse; |
| 11418 | } |
| 11419 | |
| 11420 | mDNSlocal mDNSBool LocalRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q) |
| 11421 | { |
| 11422 | AuthRecord *rr; |
| 11423 | AuthGroup *ag; |
| 11424 | |
| 11425 | if (m->CurrentQuestion) |
| 11426 | LogMsg("LocalRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 11427 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 11428 | |
| 11429 | if (IsQuestionNew(m, q)) |
| 11430 | { |
| 11431 | LogInfo("LocalRecordRmvEventsForQuestion: New Question %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 11432 | return mDNStrue; |
| 11433 | } |
| 11434 | m->CurrentQuestion = q; |
| 11435 | ag = AuthGroupForName(&m->rrauth, q->qnamehash, &q->qname); |
| 11436 | if (ag) |
| 11437 | { |
| 11438 | for (rr = ag->members; rr; rr=rr->next) |
| 11439 | // Filter the /etc/hosts records - LocalOnly, Unique, A/AAAA/CNAME |
| 11440 | if (UniqueLocalOnlyRecord(rr) && LocalOnlyRecordAnswersQuestion(rr, q)) |
| 11441 | { |
| 11442 | LogInfo("LocalRecordRmvEventsForQuestion: Delivering possible Rmv events with record %s" , |
| 11443 | ARDisplayString(m, rr)); |
| 11444 | if (q->CurrentAnswers <= 0 || q->LOAddressAnswers <= 0) |
| 11445 | { |
| 11446 | LogMsg("LocalRecordRmvEventsForQuestion: ERROR!! CurrentAnswers or LOAddressAnswers is zero %p %##s" |
| 11447 | " (%s) CurrentAnswers %d, LOAddressAnswers %d" , q, q->qname.c, DNSTypeName(q->qtype), |
| 11448 | q->CurrentAnswers, q->LOAddressAnswers); |
| 11449 | continue; |
| 11450 | } |
| 11451 | AnswerLocalQuestionWithLocalAuthRecord(m, rr, QC_rmv); // MUST NOT dereference q again |
| 11452 | if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; } |
| 11453 | } |
| 11454 | } |
| 11455 | m->CurrentQuestion = mDNSNULL; |
| 11456 | return mDNStrue; |
| 11457 | } |
| 11458 | |
| 11459 | // Returns false if the question got deleted while delivering the RMV events |
| 11460 | // The caller should handle the case |
| 11461 | mDNSexport mDNSBool CacheRecordRmvEventsForQuestion(mDNS *const m, DNSQuestion *q) |
| 11462 | { |
| 11463 | if (m->CurrentQuestion) |
| 11464 | LogMsg("CacheRecordRmvEventsForQuestion: ERROR m->CurrentQuestion already set: %##s (%s)" , |
| 11465 | m->CurrentQuestion->qname.c, DNSTypeName(m->CurrentQuestion->qtype)); |
| 11466 | |
| 11467 | // If it is a new question, we have not delivered any ADD events yet. So, don't deliver RMV events. |
| 11468 | // If this question was answered using local auth records, then you can't deliver RMVs using cache |
| 11469 | if (!IsQuestionNew(m, q) && !q->LOAddressAnswers) |
| 11470 | { |
| 11471 | m->CurrentQuestion = q; |
| 11472 | CacheRecordRmvEventsForCurrentQuestion(m, q); |
| 11473 | if (m->CurrentQuestion != q) { m->CurrentQuestion = mDNSNULL; return mDNSfalse; } |
| 11474 | m->CurrentQuestion = mDNSNULL; |
| 11475 | } |
| 11476 | else { LogInfo("CacheRecordRmvEventsForQuestion: Question %p %##s (%s) is a new question" , q, q->qname.c, DNSTypeName(q->qtype)); } |
| 11477 | return mDNStrue; |
| 11478 | } |
| 11479 | |
| 11480 | mDNSlocal void SuppressStatusChanged(mDNS *const m, DNSQuestion *q, DNSQuestion **restart) |
| 11481 | { |
| 11482 | // NOTE: CacheRecordRmvEventsForQuestion will not generate RMV events for queries that have non-zero |
| 11483 | // LOAddressAnswers. Hence it is important that we call CacheRecordRmvEventsForQuestion before |
| 11484 | // LocalRecordRmvEventsForQuestion (which decrements LOAddressAnswers) |
| 11485 | if (q->SuppressQuery) |
| 11486 | { |
| 11487 | q->SuppressQuery = mDNSfalse; |
| 11488 | if (!CacheRecordRmvEventsForQuestion(m, q)) |
| 11489 | { |
| 11490 | LogInfo("SuppressStatusChanged: Question deleted while delivering RMV events from cache" ); |
| 11491 | return; |
| 11492 | } |
| 11493 | q->SuppressQuery = mDNStrue; |
| 11494 | } |
| 11495 | |
| 11496 | // SuppressUnusable does not affect questions that are answered from the local records (/etc/hosts) |
| 11497 | // and SuppressQuery status does not mean anything for these questions. As we are going to stop the |
| 11498 | // question below, we need to deliver the RMV events so that the ADDs that will be delivered during |
| 11499 | // the restart will not be a duplicate ADD |
| 11500 | if (!LocalRecordRmvEventsForQuestion(m, q)) |
| 11501 | { |
| 11502 | LogInfo("SuppressStatusChanged: Question deleted while delivering RMV events from Local AuthRecords" ); |
| 11503 | return; |
| 11504 | } |
| 11505 | |
| 11506 | // There are two cases here. |
| 11507 | // |
| 11508 | // 1. Previously it was suppressed and now it is not suppressed, restart the question so |
| 11509 | // that it will start as a new question. Note that we can't just call ActivateUnicastQuery |
| 11510 | // because when we get the response, if we had entries in the cache already, it will not answer |
| 11511 | // this question if the cache entry did not change. Hence, we need to restart |
| 11512 | // the query so that it can be answered from the cache. |
| 11513 | // |
| 11514 | // 2. Previously it was not suppressed and now it is suppressed. We need to restart the questions |
| 11515 | // so that we redo the duplicate checks in mDNS_StartQuery_internal. A SuppressUnusable question |
| 11516 | // is a duplicate of non-SuppressUnusable question if it is not suppressed (SuppressQuery is false). |
| 11517 | // A SuppressUnusable question is not a duplicate of non-SuppressUnusable question if it is suppressed |
| 11518 | // (SuppressQuery is true). The reason for this is that when a question is suppressed, we want an |
| 11519 | // immediate response and not want to be blocked behind a question that is querying DNS servers. When |
| 11520 | // the question is not suppressed, we don't want two active questions sending packets on the wire. |
| 11521 | // This affects both efficiency and also the current design where there is only one active question |
| 11522 | // pointed to from a cache entry. |
| 11523 | // |
| 11524 | // We restart queries in a two step process by first calling stop and build a temporary list which we |
| 11525 | // will restart at the end. The main reason for the two step process is to handle duplicate questions. |
| 11526 | // If there are duplicate questions, calling stop inherits the values from another question on the list (which |
| 11527 | // will soon become the real question) including q->ThisQInterval which might be zero if it was |
| 11528 | // suppressed before. At the end when we have restarted all questions, none of them is active as each |
| 11529 | // inherits from one another and we need to reactivate one of the questions here which is a little hacky. |
| 11530 | // |
| 11531 | // It is much cleaner and less error prone to build a list of questions and restart at the end. |
| 11532 | |
| 11533 | LogInfo("SuppressStatusChanged: Stop question %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 11534 | mDNS_StopQuery_internal(m, q); |
| 11535 | q->next = *restart; |
| 11536 | *restart = q; |
| 11537 | } |
| 11538 | |
| 11539 | // The caller should hold the lock |
| 11540 | mDNSexport void CheckSuppressUnusableQuestions(mDNS *const m) |
| 11541 | { |
| 11542 | DNSQuestion *q; |
| 11543 | DNSQuestion *restart = mDNSNULL; |
| 11544 | |
| 11545 | // We look through all questions including new questions. During network change events, |
| 11546 | // we potentially restart questions here in this function that ends up as new questions, |
| 11547 | // which may be suppressed at this instance. Before it is handled we get another network |
| 11548 | // event that changes the status e.g., address becomes available. If we did not process |
| 11549 | // new questions, we would never change its SuppressQuery status. |
| 11550 | // |
| 11551 | // CurrentQuestion is used by RmvEventsForQuestion below. While delivering RMV events, the |
| 11552 | // application callback can potentially stop the current question (detected by CurrentQuestion) or |
| 11553 | // *any* other question which could be the next one that we may process here. RestartQuestion |
| 11554 | // points to the "next" question which will be automatically advanced in mDNS_StopQuery_internal |
| 11555 | // if the "next" question is stopped while the CurrentQuestion is stopped |
| 11556 | if (m->RestartQuestion) |
| 11557 | LogMsg("CheckSuppressUnusableQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)" , |
| 11558 | m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); |
| 11559 | m->RestartQuestion = m->Questions; |
| 11560 | while (m->RestartQuestion) |
| 11561 | { |
| 11562 | q = m->RestartQuestion; |
| 11563 | m->RestartQuestion = q->next; |
| 11564 | if (q->SuppressUnusable) |
| 11565 | { |
| 11566 | mDNSBool old = q->SuppressQuery; |
| 11567 | q->SuppressQuery = ShouldSuppressQuery(m, q); |
| 11568 | if (q->SuppressQuery != old) |
| 11569 | { |
| 11570 | // Previously it was not suppressed, Generate RMV events for the ADDs that we might have delivered before |
| 11571 | // followed by a negative cache response. Temporarily turn off suppression so that |
| 11572 | // AnswerCurrentQuestionWithResourceRecord can answer the question |
| 11573 | SuppressStatusChanged(m, q, &restart); |
| 11574 | } |
| 11575 | } |
| 11576 | } |
| 11577 | while (restart) |
| 11578 | { |
| 11579 | q = restart; |
| 11580 | restart = restart->next; |
| 11581 | q->next = mDNSNULL; |
| 11582 | LogInfo("CheckSuppressUnusableQuestions: Start question %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 11583 | mDNS_StartQuery_internal(m, q); |
| 11584 | } |
| 11585 | } |
| 11586 | |
| 11587 | mDNSlocal void RestartUnicastQuestions(mDNS *const m) |
| 11588 | { |
| 11589 | DNSQuestion *q; |
| 11590 | DNSQuestion *restart = mDNSNULL; |
| 11591 | |
| 11592 | if (m->RestartQuestion) |
| 11593 | LogMsg("RestartUnicastQuestions: ERROR!! m->RestartQuestion already set: %##s (%s)" , |
| 11594 | m->RestartQuestion->qname.c, DNSTypeName(m->RestartQuestion->qtype)); |
| 11595 | m->RestartQuestion = m->Questions; |
| 11596 | while (m->RestartQuestion) |
| 11597 | { |
| 11598 | q = m->RestartQuestion; |
| 11599 | m->RestartQuestion = q->next; |
| 11600 | if (q->Restart) |
| 11601 | { |
| 11602 | if (mDNSOpaque16IsZero(q->TargetQID)) |
| 11603 | LogMsg("RestartUnicastQuestions: ERROR!! Restart set for multicast question %##s (%s)" , q->qname.c, DNSTypeName(q->qtype)); |
| 11604 | |
| 11605 | q->Restart = 0; |
| 11606 | SuppressStatusChanged(m, q, &restart); |
| 11607 | } |
| 11608 | } |
| 11609 | while (restart) |
| 11610 | { |
| 11611 | q = restart; |
| 11612 | restart = restart->next; |
| 11613 | q->next = mDNSNULL; |
| 11614 | LogInfo("RestartUnicastQuestions: Start question %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 11615 | mDNS_StartQuery_internal(m, q); |
| 11616 | } |
| 11617 | } |
| 11618 | |
| 11619 | |
| 11620 | // ValidateParameters() is called by mDNS_StartQuery_internal() to check the client parameters of |
| 11621 | // DNS Question that are already set by the client before calling mDNS_StartQuery() |
| 11622 | mDNSlocal mStatus ValidateParameters(mDNS *const m, DNSQuestion *const question) |
| 11623 | { |
| 11624 | |
| 11625 | if (question->Target.type && !ValidQuestionTarget(question)) |
| 11626 | { |
| 11627 | LogMsg("ValidateParameters: Warning! Target.type = %ld port = %u (Client forgot to initialize before calling mDNS_StartQuery? for question %##s)" , |
| 11628 | question->Target.type, mDNSVal16(question->TargetPort), question->qname.c); |
| 11629 | question->Target.type = mDNSAddrType_None; |
| 11630 | } |
| 11631 | |
| 11632 | // If no question->Target specified, clear TargetPort |
| 11633 | if (!question->Target.type) |
| 11634 | question->TargetPort = zeroIPPort; |
| 11635 | |
| 11636 | if (!ValidateDomainName(&question->qname)) |
| 11637 | { |
| 11638 | LogMsg("ValidateParameters: Attempt to start query with invalid qname %##s (%s)" , question->qname.c, DNSTypeName(question->qtype)); |
| 11639 | return(mStatus_Invalid); |
| 11640 | } |
| 11641 | |
| 11642 | // If this question is referencing a specific interface, verify it exists |
| 11643 | if (question->InterfaceID && !LocalOnlyOrP2PInterface(question->InterfaceID) && question->InterfaceID != mDNSInterface_Unicast) |
| 11644 | { |
| 11645 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, question->InterfaceID); |
| 11646 | if (!intf) |
| 11647 | LogInfo("ValidateParameters: Note: InterfaceID %d for question %##s (%s) not currently found in active interface list" , |
| 11648 | IID(question->InterfaceID), question->qname.c, DNSTypeName(question->qtype)); |
| 11649 | } |
| 11650 | |
| 11651 | return(mStatus_NoError); |
| 11652 | } |
| 11653 | |
| 11654 | // InitDNSConfig() is called by InitCommonState() to initialize the DNS configuration of the Question. |
| 11655 | // These are a subset of the internal uDNS fields. Must be done before ShouldSuppressQuery() & mDNS_PurgeForQuestion() |
| 11656 | mDNSlocal void InitDNSConfig(mDNS *const m, DNSQuestion *const question) |
| 11657 | { |
| 11658 | // First reset all DNS Configuration |
| 11659 | question->qDNSServer = mDNSNULL; |
| 11660 | question->validDNSServers = zeroOpaque128; |
| 11661 | question->triedAllServersOnce = 0; |
| 11662 | question->noServerResponse = 0; |
| 11663 | question->StopTime = (question->TimeoutQuestion) ? question->StopTime : 0; |
| 11664 | #if AWD_METRICS |
| 11665 | mDNSPlatformMemZero(&question->metrics, sizeof(question->metrics)); |
| 11666 | #endif |
| 11667 | |
| 11668 | // Need not initialize the DNS Configuration for Local Only OR P2P Questions when timeout not specified |
| 11669 | if (LocalOnlyOrP2PInterface(question->InterfaceID) && !question->TimeoutQuestion) |
| 11670 | return; |
| 11671 | // Proceed to initialize DNS Configuration (some are set in SetValidDNSServers()) |
| 11672 | if (!mDNSOpaque16IsZero(question->TargetQID)) |
| 11673 | { |
| 11674 | mDNSu32 timeout = SetValidDNSServers(m, question); |
| 11675 | // We set the timeout value the first time mDNS_StartQuery_internal is called for a question. |
| 11676 | // So if a question is restarted when a network change occurs, the StopTime is not reset. |
| 11677 | // Note that we set the timeout for all questions. If this turns out to be a duplicate, |
| 11678 | // it gets a full timeout value even if the original question times out earlier. |
| 11679 | if (question->TimeoutQuestion && !question->StopTime) |
| 11680 | { |
| 11681 | question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); |
| 11682 | LogInfo("InitDNSConfig: Setting StopTime on the uDNS question %p %##s (%s)" , question, question->qname.c, DNSTypeName(question->qtype)); |
| 11683 | } |
| 11684 | |
| 11685 | question->qDNSServer = GetServerForQuestion(m, question); |
| 11686 | LogInfo("InitDNSConfig: question %p %##s (%s) Timeout %d, DNS Server %#a:%d" , |
| 11687 | question, question->qname.c, DNSTypeName(question->qtype), timeout, |
| 11688 | question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, |
| 11689 | mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort)); |
| 11690 | } |
| 11691 | else if (question->TimeoutQuestion && !question->StopTime) |
| 11692 | { |
| 11693 | // If the question is to be timed out and its a multicast, local-only or P2P case, |
| 11694 | // then set it's stop time. |
| 11695 | mDNSu32 timeout = LocalOnlyOrP2PInterface(question->InterfaceID) ? |
| 11696 | DEFAULT_LO_OR_P2P_TIMEOUT : GetTimeoutForMcastQuestion(m, question); |
| 11697 | question->StopTime = NonZeroTime(m->timenow + timeout * mDNSPlatformOneSecond); |
| 11698 | LogInfo("InitDNSConfig: Setting StopTime on question %p %##s (%s)" , question, question->qname.c, DNSTypeName(question->qtype)); |
| 11699 | } |
| 11700 | // Set StopTime here since it is a part of DNS Configuration |
| 11701 | if (question->StopTime) |
| 11702 | SetNextQueryStopTime(m, question); |
| 11703 | // Don't call SetNextQueryTime() if a LocalOnly OR P2P Question since those questions |
| 11704 | // will never be transmitted on the wire. |
| 11705 | if (!(LocalOnlyOrP2PInterface(question->InterfaceID))) |
| 11706 | SetNextQueryTime(m,question); |
| 11707 | } |
| 11708 | |
| 11709 | // InitCommonState() is called by mDNS_StartQuery_internal() to initialize the common(uDNS/mDNS) internal |
| 11710 | // state fields of the DNS Question. These are independent of the Client layer. |
| 11711 | mDNSlocal mDNSBool InitCommonState(mDNS *const m, DNSQuestion *const question) |
| 11712 | { |
| 11713 | mDNSBool purge; |
| 11714 | int i; |
| 11715 | mDNSBool isBlocked = mDNSfalse; |
| 11716 | |
| 11717 | // Note: In the case where we already have the answer to this question in our cache, that may be all the client |
| 11718 | // wanted, and they may immediately cancel their question. In this case, sending an actual query on the wire would |
| 11719 | // be a waste. For that reason, we schedule our first query to go out in half a second (InitialQuestionInterval). |
| 11720 | // If AnswerNewQuestion() finds that we have *no* relevant answers currently in our cache, then it will accelerate |
| 11721 | // that to go out immediately. |
| 11722 | question->next = mDNSNULL; |
| 11723 | // ThisQInterval should be initialized before any memory allocations occur. If malloc |
| 11724 | // debugging is turned on within mDNSResponder (see mDNSDebug.h for details) it validates |
| 11725 | // the question list to check if ThisQInterval is negative which means the question has been |
| 11726 | // stopped and can't be on the list. The question is already on the list and ThisQInterval |
| 11727 | // can be negative if the caller just stopped it and starting it again. Hence, it always has to |
| 11728 | // be initialized. CheckForSoonToExpireRecords below prints the cache records when logging is |
| 11729 | // turned ON which can allocate memory e.g., base64 encoding, in the case of DNSSEC. |
| 11730 | question->ThisQInterval = InitialQuestionInterval; // MUST be > zero for an active question |
| 11731 | question->qnamehash = DomainNameHashValue(&question->qname); |
| 11732 | question->DelayAnswering = CheckForSoonToExpireRecords(m, &question->qname, question->qnamehash, &purge); |
| 11733 | question->LastQTime = m->timenow; |
| 11734 | question->ExpectUnicastResp = 0; |
| 11735 | question->LastAnswerPktNum = m->PktNum; |
| 11736 | question->RecentAnswerPkts = 0; |
| 11737 | question->CurrentAnswers = 0; |
| 11738 | |
| 11739 | #if APPLE_OSX_mDNSResponder |
| 11740 | |
| 11741 | // Initial browse threshold used by Finder. |
| 11742 | #define mDNSFinderBrowseThreshold 20 |
| 11743 | |
| 11744 | // Set the threshold at which we move to a passive browse state, |
| 11745 | // not actively sending queries. |
| 11746 | if (question->flags & kDNSServiceFlagsThresholdOne) |
| 11747 | question->BrowseThreshold = 1; |
| 11748 | else if (question->flags & kDNSServiceFlagsThresholdFinder) |
| 11749 | question->BrowseThreshold = mDNSFinderBrowseThreshold; |
| 11750 | else |
| 11751 | question->BrowseThreshold = 0; |
| 11752 | |
| 11753 | #else // APPLE_OSX_mDNSResponder |
| 11754 | question->BrowseThreshold = 0; |
| 11755 | #endif // APPLE_OSX_mDNSResponder |
| 11756 | question->CachedAnswerNeedsUpdate = mDNSfalse; |
| 11757 | |
| 11758 | question->LargeAnswers = 0; |
| 11759 | question->UniqueAnswers = 0; |
| 11760 | question->LOAddressAnswers = 0; |
| 11761 | question->FlappingInterface1 = mDNSNULL; |
| 11762 | question->FlappingInterface2 = mDNSNULL; |
| 11763 | |
| 11764 | // if kDNSServiceFlagsServiceIndex flag is SET by the client, then do NOT call mDNSPlatformGetDNSRoutePolicy() |
| 11765 | // since we would already have the question->ServiceID in that case. |
| 11766 | if (!(question->flags & kDNSServiceFlagsServiceIndex)) |
| 11767 | { |
| 11768 | #if APPLE_OSX_mDNSResponder |
| 11769 | mDNSPlatformGetDNSRoutePolicy(question, &isBlocked); |
| 11770 | #else |
| 11771 | question->ServiceID = -1; |
| 11772 | #endif |
| 11773 | } |
| 11774 | else |
| 11775 | LogInfo("InitCommonState: Query for %##s (%s), PID[%d], EUID[%d], ServiceID[%d] is already set by client" , question->qname.c, |
| 11776 | DNSTypeName(question->qtype), question->pid, question->euid, question->ServiceID); |
| 11777 | |
| 11778 | InitDNSConfig(m, question); |
| 11779 | |
| 11780 | question->AuthInfo = GetAuthInfoForQuestion(m, question); |
| 11781 | question->SuppressQuery = 0; |
| 11782 | if (question->SuppressUnusable) |
| 11783 | question->SuppressQuery = ShouldSuppressQuery(m, question); |
| 11784 | |
| 11785 | // If ServiceID is 0 or the policy disallows making DNS requests, |
| 11786 | // set DisallowPID |
| 11787 | question->DisallowPID = (question->ServiceID == 0 || isBlocked); |
| 11788 | if (question->DisallowPID) |
| 11789 | LogInfo("InitCommonState: Query suppressed for %##s (%s), PID %d/ServiceID %d not allowed" , question->qname.c, |
| 11790 | DNSTypeName(question->qtype), question->pid, question->ServiceID); |
| 11791 | |
| 11792 | question->NextInDQList = mDNSNULL; |
| 11793 | question->SendQNow = mDNSNULL; |
| 11794 | question->SendOnAll = mDNSfalse; |
| 11795 | question->RequestUnicast = kDefaultRequestUnicastCount; |
| 11796 | |
| 11797 | #if APPLE_OSX_mDNSResponder |
| 11798 | // Set the QU bit in the first query for the following options. |
| 11799 | if ((question->flags & kDNSServiceFlagsUnicastResponse) || (question->flags & kDNSServiceFlagsThresholdFinder)) |
| 11800 | { |
| 11801 | question->RequestUnicast = SET_QU_IN_FIRST_QUERY; |
| 11802 | LogInfo("InitCommonState: setting RequestUnicast = %d for %##s (%s)" , question->RequestUnicast, question->qname.c, |
| 11803 | DNSTypeName(question->qtype)); |
| 11804 | } |
| 11805 | #endif // APPLE_OSX_mDNSResponder |
| 11806 | |
| 11807 | question->LastQTxTime = m->timenow; |
| 11808 | question->CNAMEReferrals = 0; |
| 11809 | |
| 11810 | question->WakeOnResolveCount = 0; |
| 11811 | if (question->WakeOnResolve) |
| 11812 | { |
| 11813 | question->WakeOnResolveCount = InitialWakeOnResolveCount; |
| 11814 | purge = mDNStrue; |
| 11815 | } |
| 11816 | |
| 11817 | for (i=0; i<DupSuppressInfoSize; i++) |
| 11818 | question->DupSuppress[i].InterfaceID = mDNSNULL; |
| 11819 | |
| 11820 | question->Restart = 0; |
| 11821 | |
| 11822 | debugf("InitCommonState: Question %##s (%s) Interface %p Now %d Send in %d Answer in %d (%p) %s (%p)" , |
| 11823 | question->qname.c, DNSTypeName(question->qtype), question->InterfaceID, m->timenow, |
| 11824 | NextQSendTime(question) - m->timenow, |
| 11825 | question->DelayAnswering ? question->DelayAnswering - m->timenow : 0, |
| 11826 | question, question->DuplicateOf ? "duplicate of" : "not duplicate" , question->DuplicateOf); |
| 11827 | |
| 11828 | if (question->DelayAnswering) |
| 11829 | LogInfo("InitCommonState: Delaying answering for %d ticks while cache stabilizes for %##s (%s)" , |
| 11830 | question->DelayAnswering - m->timenow, question->qname.c, DNSTypeName(question->qtype)); |
| 11831 | |
| 11832 | return(purge); |
| 11833 | } |
| 11834 | |
| 11835 | // Excludes the DNS Config fields which are already handled by InitDNSConfig() |
| 11836 | mDNSlocal void InitWABState(DNSQuestion *const question) |
| 11837 | { |
| 11838 | // We'll create our question->LocalSocket on demand, if needed. |
| 11839 | // We won't need one for duplicate questions, or from questions answered immediately out of the cache. |
| 11840 | // We also don't need one for LLQs because (when we're using NAT) we want them all to share a single |
| 11841 | // NAT mapping for receiving inbound add/remove events. |
| 11842 | question->LocalSocket = mDNSNULL; |
| 11843 | question->unansweredQueries = 0; |
| 11844 | question->nta = mDNSNULL; |
| 11845 | question->servAddr = zeroAddr; |
| 11846 | question->servPort = zeroIPPort; |
| 11847 | question->tcp = mDNSNULL; |
| 11848 | question->NoAnswer = NoAnswer_Normal; |
| 11849 | } |
| 11850 | |
| 11851 | mDNSlocal void InitLLQNATState(mDNS *const m) |
| 11852 | { |
| 11853 | // If we don't have our NAT mapping active, start it now |
| 11854 | if (!m->LLQNAT.clientCallback) |
| 11855 | { |
| 11856 | m->LLQNAT.Protocol = NATOp_MapUDP; |
| 11857 | m->LLQNAT.IntPort = m->UnicastPort4; |
| 11858 | m->LLQNAT.RequestedPort = m->UnicastPort4; |
| 11859 | m->LLQNAT.clientCallback = LLQNATCallback; |
| 11860 | m->LLQNAT.clientContext = (void*)1; // Means LLQ NAT Traversal just started |
| 11861 | mDNS_StartNATOperation_internal(m, &m->LLQNAT); |
| 11862 | } |
| 11863 | } |
| 11864 | |
| 11865 | mDNSlocal void InitLLQState(DNSQuestion *const question) |
| 11866 | { |
| 11867 | question->state = LLQ_InitialRequest; |
| 11868 | question->ReqLease = 0; |
| 11869 | question->expire = 0; |
| 11870 | question->ntries = 0; |
| 11871 | question->id = zeroOpaque64; |
| 11872 | } |
| 11873 | |
| 11874 | #ifdef DNS_PUSH_ENABLED |
| 11875 | mDNSlocal void InitDNSPNState(DNSQuestion *const question) |
| 11876 | { |
| 11877 | question->dnsPushState = DNSPUSH_INIT; |
| 11878 | } |
| 11879 | #endif // DNS_PUSH_ENABLED |
| 11880 | |
| 11881 | // InitDNSSECProxyState() is called by mDNS_StartQuery_internal() to initialize |
| 11882 | // DNSSEC & DNS Proxy fields of the DNS Question. |
| 11883 | mDNSlocal void InitDNSSECProxyState(mDNS *const m, DNSQuestion *const question) |
| 11884 | { |
| 11885 | (void) m; |
| 11886 | |
| 11887 | // DNS server selection affects DNSSEC. Turn off validation if req_DO is not set |
| 11888 | // or the request is going over cellular interface. |
| 11889 | // |
| 11890 | // Note: This needs to be done here before we call FindDuplicateQuestion as it looks |
| 11891 | // at ValidationRequired setting also. |
| 11892 | if (question->qDNSServer) |
| 11893 | { |
| 11894 | if (question->qDNSServer->cellIntf) |
| 11895 | { |
| 11896 | debugf("InitDNSSECProxyState: Turning off validation for %##s (%s); going over cell" , question->qname.c, DNSTypeName(question->qtype)); |
| 11897 | question->ValidationRequired = mDNSfalse; |
| 11898 | } |
| 11899 | if (DNSSECOptionalQuestion(question) && !(question->qDNSServer->req_DO)) |
| 11900 | { |
| 11901 | LogInfo("InitDNSSECProxyState: Turning off validation for %##s (%s); req_DO false" , |
| 11902 | question->qname.c, DNSTypeName(question->qtype)); |
| 11903 | question->ValidationRequired = DNSSEC_VALIDATION_NONE; |
| 11904 | } |
| 11905 | } |
| 11906 | question->ValidationState = (question->ValidationRequired ? DNSSECValRequired : DNSSECValNotRequired); |
| 11907 | question->ValidationStatus = 0; |
| 11908 | question->responseFlags = zeroID; |
| 11909 | } |
| 11910 | |
| 11911 | // Once the question is completely initialized including the duplicate logic, this function |
| 11912 | // is called to finalize the unicast question which requires flushing the cache if needed, |
| 11913 | // activating the query etc. |
| 11914 | mDNSlocal void FinalizeUnicastQuestion(mDNS *const m, DNSQuestion *question, mDNSBool purge) |
| 11915 | { |
| 11916 | // Ensure DNS related info of duplicate question is same as the orig question |
| 11917 | if (question->DuplicateOf) |
| 11918 | { |
| 11919 | question->validDNSServers = question->DuplicateOf->validDNSServers; |
| 11920 | // If current(dup) question has DNS Server assigned but the original question has no DNS Server assigned to it, |
| 11921 | // then we log a line as it could indicate an issue |
| 11922 | if (question->DuplicateOf->qDNSServer == mDNSNULL) |
| 11923 | { |
| 11924 | if (question->qDNSServer) |
| 11925 | LogInfo("FinalizeUnicastQuestion: Current(dup) question %p has DNSServer(%#a:%d) but original question(%p) has no DNS Server! %##s (%s)" , |
| 11926 | question, question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, |
| 11927 | mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort), |
| 11928 | question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype)); |
| 11929 | } |
| 11930 | question->qDNSServer = question->DuplicateOf->qDNSServer; |
| 11931 | LogInfo("FinalizeUnicastQuestion: Duplicate question %p (%p) %##s (%s), DNS Server %#a:%d" , |
| 11932 | question, question->DuplicateOf, question->qname.c, DNSTypeName(question->qtype), |
| 11933 | question->qDNSServer ? &question->qDNSServer->addr : mDNSNULL, |
| 11934 | mDNSVal16(question->qDNSServer ? question->qDNSServer->port : zeroIPPort)); |
| 11935 | } |
| 11936 | |
| 11937 | ActivateUnicastQuery(m, question, mDNSfalse); |
| 11938 | |
| 11939 | // If purge was set above, flush the cache. Need to do this after we set the |
| 11940 | // DNS server on the question |
| 11941 | if (purge) |
| 11942 | { |
| 11943 | question->DelayAnswering = 0; |
| 11944 | mDNS_PurgeForQuestion(m, question); |
| 11945 | } |
| 11946 | else if (!question->DuplicateOf && DNSSECQuestion(question)) |
| 11947 | { |
| 11948 | // For DNSSEC questions, we need to have the RRSIGs also for verification. |
| 11949 | CheckForDNSSECRecords(m, question); |
| 11950 | } |
| 11951 | if (question->LongLived) |
| 11952 | { |
| 11953 | // Unlike other initializations, InitLLQNATState should be done after |
| 11954 | // we determine that it is a unicast question. LongLived is set for |
| 11955 | // both multicast and unicast browse questions but we should initialize |
| 11956 | // the LLQ NAT state only for unicast. Otherwise we will unnecessarily |
| 11957 | // start the NAT traversal that is not needed. |
| 11958 | InitLLQNATState(m); |
| 11959 | #if APPLE_OSX_mDNSResponder |
| 11960 | UpdateAutoTunnelDomainStatuses(m); |
| 11961 | #endif |
| 11962 | } |
| 11963 | } |
| 11964 | |
| 11965 | mDNSexport mStatus mDNS_StartQuery_internal(mDNS *const m, DNSQuestion *const question) |
| 11966 | { |
| 11967 | DNSQuestion **q; |
| 11968 | mStatus vStatus; |
| 11969 | mDNSBool purge; |
| 11970 | |
| 11971 | // First check for cache space (can't do queries if there is no cache space allocated) |
| 11972 | if (m->rrcache_size == 0) |
| 11973 | return(mStatus_NoCache); |
| 11974 | |
| 11975 | vStatus = ValidateParameters(m, question); |
| 11976 | if (vStatus) |
| 11977 | return(vStatus); |
| 11978 | |
| 11979 | #ifdef USE_LIBIDN |
| 11980 | // If the TLD includes high-ascii bytes, assume it will need to be converted to Punycode. |
| 11981 | // (In the future the root name servers may answer UTF-8 queries directly, but for now they do not.) |
| 11982 | if (IsHighASCIILabel(LastLabel(&question->qname))) |
| 11983 | { |
| 11984 | domainname newname; |
| 11985 | if (PerformNextPunycodeConversion(question, &newname)) |
| 11986 | AssignDomainName(&question->qname, &newname); |
| 11987 | } |
| 11988 | #endif // USE_LIBIDN |
| 11989 | |
| 11990 | question->TargetQID = |
| 11991 | #ifndef UNICAST_DISABLED |
| 11992 | (question->Target.type || Question_uDNS(question)) ? mDNS_NewMessageID(m) : |
| 11993 | #endif // UNICAST_DISABLED |
| 11994 | zeroID; |
| 11995 | debugf("mDNS_StartQuery_internal: %##s (%s)" , question->qname.c, DNSTypeName(question->qtype)); |
| 11996 | |
| 11997 | // Note: It important that new questions are appended at the *end* of the list, not prepended at the start |
| 11998 | q = &m->Questions; |
| 11999 | if (LocalOnlyOrP2PInterface(question->InterfaceID)) |
| 12000 | q = &m->LocalOnlyQuestions; |
| 12001 | while (*q && *q != question) |
| 12002 | q=&(*q)->next; |
| 12003 | |
| 12004 | if (*q) |
| 12005 | { |
| 12006 | LogMsg("mDNS_StartQuery_internal: Error! Tried to add a question %##s (%s) %p that's already in the active list" , |
| 12007 | question->qname.c, DNSTypeName(question->qtype), question); |
| 12008 | return(mStatus_AlreadyRegistered); |
| 12009 | } |
| 12010 | *q = question; |
| 12011 | |
| 12012 | // Intialize the question. The only ordering constraint we have today is that |
| 12013 | // InitDNSSECProxyState should be called after the DNS server is selected (in |
| 12014 | // InitCommonState -> InitDNSConfig) as DNS server selection affects DNSSEC |
| 12015 | // validation. |
| 12016 | |
| 12017 | purge = InitCommonState(m, question); |
| 12018 | InitWABState(question); |
| 12019 | InitLLQState(question); |
| 12020 | #ifdef DNS_PUSH_ENABLED |
| 12021 | InitDNSPNState(question); |
| 12022 | #endif // DNS_PUSH_ENABLED |
| 12023 | InitDNSSECProxyState(m, question); |
| 12024 | |
| 12025 | // FindDuplicateQuestion should be called last after all the intialization |
| 12026 | // as the duplicate logic could be potentially based on any field in the |
| 12027 | // question. |
| 12028 | question->DuplicateOf = FindDuplicateQuestion(m, question); |
| 12029 | if (question->DuplicateOf) |
| 12030 | question->AuthInfo = question->DuplicateOf->AuthInfo; |
| 12031 | |
| 12032 | if (LocalOnlyOrP2PInterface(question->InterfaceID)) |
| 12033 | { |
| 12034 | if (!m->NewLocalOnlyQuestions) |
| 12035 | m->NewLocalOnlyQuestions = question; |
| 12036 | } |
| 12037 | else |
| 12038 | { |
| 12039 | if (!m->NewQuestions) |
| 12040 | m->NewQuestions = question; |
| 12041 | |
| 12042 | // If the question's id is non-zero, then it's Wide Area |
| 12043 | // MUST NOT do this Wide Area setup until near the end of |
| 12044 | // mDNS_StartQuery_internal -- this code may itself issue queries (e.g. SOA, |
| 12045 | // NS, etc.) and if we haven't finished setting up our own question and setting |
| 12046 | // m->NewQuestions if necessary then we could end up recursively re-entering |
| 12047 | // this routine with the question list data structures in an inconsistent state. |
| 12048 | if (!mDNSOpaque16IsZero(question->TargetQID)) |
| 12049 | { |
| 12050 | FinalizeUnicastQuestion(m, question, purge); |
| 12051 | } |
| 12052 | else |
| 12053 | { |
| 12054 | #if BONJOUR_ON_DEMAND |
| 12055 | m->NumAllInterfaceQuestions++; |
| 12056 | LogInfo("mDNS_StartQuery_internal: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %##s (%s)" , |
| 12057 | m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, question->qname.c, DNSTypeName(question->qtype)); |
| 12058 | if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) |
| 12059 | { |
| 12060 | m->NextBonjourDisableTime = 0; |
| 12061 | if (m->BonjourEnabled == 0) |
| 12062 | { |
| 12063 | // Enable Bonjour immediately by scheduling network changed processing where |
| 12064 | // we will join the multicast group on each active interface. |
| 12065 | m->BonjourEnabled = 1; |
| 12066 | m->NetworkChanged = m->timenow; |
| 12067 | } |
| 12068 | } |
| 12069 | #endif // BONJOUR_ON_DEMAND |
| 12070 | if (purge) |
| 12071 | { |
| 12072 | LogInfo("mDNS_StartQuery_internal: Purging for %##s" , question->qname.c); |
| 12073 | mDNS_PurgeForQuestion(m, question); |
| 12074 | } |
| 12075 | } |
| 12076 | } |
| 12077 | |
| 12078 | return(mStatus_NoError); |
| 12079 | } |
| 12080 | |
| 12081 | // CancelGetZoneData is an internal routine (i.e. must be called with the lock already held) |
| 12082 | mDNSexport void CancelGetZoneData(mDNS *const m, ZoneData *nta) |
| 12083 | { |
| 12084 | debugf("CancelGetZoneData %##s (%s)" , nta->question.qname.c, DNSTypeName(nta->question.qtype)); |
| 12085 | // This function may be called anytime to free the zone information.The question may or may not have stopped. |
| 12086 | // If it was already stopped, mDNS_StopQuery_internal would have set q->ThisQInterval to -1 and should not |
| 12087 | // call it again |
| 12088 | if (nta->question.ThisQInterval != -1) |
| 12089 | { |
| 12090 | mDNS_StopQuery_internal(m, &nta->question); |
| 12091 | if (nta->question.ThisQInterval != -1) |
| 12092 | LogMsg("CancelGetZoneData: Question %##s (%s) ThisQInterval %d not -1" , nta->question.qname.c, DNSTypeName(nta->question.qtype), nta->question.ThisQInterval); |
| 12093 | } |
| 12094 | mDNSPlatformMemFree(nta); |
| 12095 | } |
| 12096 | |
| 12097 | mDNSexport mStatus mDNS_StopQuery_internal(mDNS *const m, DNSQuestion *const question) |
| 12098 | { |
| 12099 | CacheGroup *cg = CacheGroupForName(m, question->qnamehash, &question->qname); |
| 12100 | CacheRecord *rr; |
| 12101 | DNSQuestion **qp = &m->Questions; |
| 12102 | |
| 12103 | //LogInfo("mDNS_StopQuery_internal %##s (%s)", question->qname.c, DNSTypeName(question->qtype)); |
| 12104 | |
| 12105 | if (LocalOnlyOrP2PInterface(question->InterfaceID)) |
| 12106 | qp = &m->LocalOnlyQuestions; |
| 12107 | while (*qp && *qp != question) qp=&(*qp)->next; |
| 12108 | if (*qp) *qp = (*qp)->next; |
| 12109 | else |
| 12110 | { |
| 12111 | #if !ForceAlerts |
| 12112 | if (question->ThisQInterval >= 0) // Only log error message if the query was supposed to be active |
| 12113 | #endif |
| 12114 | LogFatalError("mDNS_StopQuery_internal: Question %##s (%s) not found in active list" , question->qname.c, DNSTypeName(question->qtype)); |
| 12115 | return(mStatus_BadReferenceErr); |
| 12116 | } |
| 12117 | |
| 12118 | #if BONJOUR_ON_DEMAND |
| 12119 | if (!LocalOnlyOrP2PInterface(question->InterfaceID) && mDNSOpaque16IsZero(question->TargetQID)) |
| 12120 | { |
| 12121 | if (m->NumAllInterfaceRecords + m->NumAllInterfaceQuestions == 1) |
| 12122 | m->NextBonjourDisableTime = NonZeroTime(m->timenow + (BONJOUR_DISABLE_DELAY * mDNSPlatformOneSecond)); |
| 12123 | m->NumAllInterfaceQuestions--; |
| 12124 | LogInfo("mDNS_StopQuery_internal: NumAllInterfaceRecords %d NumAllInterfaceQuestions %d %##s (%s)" , |
| 12125 | m->NumAllInterfaceRecords, m->NumAllInterfaceQuestions, question->qname.c, DNSTypeName(question->qtype)); |
| 12126 | } |
| 12127 | #endif // BONJOUR_ON_DEMAND |
| 12128 | |
| 12129 | #if AWD_METRICS |
| 12130 | if (Question_uDNS(question) && !question->metrics.answered && (question->metrics.querySendCount > 0)) |
| 12131 | { |
| 12132 | const domainname * queryName; |
| 12133 | mDNSBool isForCell; |
| 12134 | mDNSu32 durationMs; |
| 12135 | |
| 12136 | queryName = question->metrics.originalQName ? question->metrics.originalQName : &question->qname; |
| 12137 | isForCell = (question->qDNSServer && question->qDNSServer->cellIntf); |
| 12138 | durationMs = ((m->timenow - question->metrics.firstQueryTime) * 1000) / mDNSPlatformOneSecond; |
| 12139 | MetricsUpdateDNSQueryStats(queryName, question->qtype, mDNSNULL, question->metrics.querySendCount, durationMs, isForCell); |
| 12140 | } |
| 12141 | #endif |
| 12142 | // Take care to cut question from list *before* calling UpdateQuestionDuplicates |
| 12143 | UpdateQuestionDuplicates(m, question); |
| 12144 | // But don't trash ThisQInterval until afterwards. |
| 12145 | question->ThisQInterval = -1; |
| 12146 | |
| 12147 | // If there are any cache records referencing this as their active question, then see if there is any |
| 12148 | // other question that is also referencing them, else their CRActiveQuestion needs to get set to NULL. |
| 12149 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 12150 | { |
| 12151 | if (rr->CRActiveQuestion == question) |
| 12152 | { |
| 12153 | DNSQuestion *q; |
| 12154 | DNSQuestion *replacement = mDNSNULL; |
| 12155 | // If we find an active question that is answered by this cached record, use it as the cache record's |
| 12156 | // CRActiveQuestion replacement. If there are no such questions, but there's at least one unsuppressed inactive |
| 12157 | // question that is answered by this cache record, then use an inactive one to not forgo generating RMV events |
| 12158 | // via CacheRecordRmv() when the cache record expires. |
| 12159 | for (q = m->Questions; q && (q != m->NewQuestions); q = q->next) |
| 12160 | { |
| 12161 | if (!q->DuplicateOf && !QuerySuppressed(q) && ResourceRecordAnswersQuestion(&rr->resrec, q)) |
| 12162 | { |
| 12163 | if (q->ThisQInterval > 0) |
| 12164 | { |
| 12165 | replacement = q; |
| 12166 | break; |
| 12167 | } |
| 12168 | else if (!replacement) |
| 12169 | { |
| 12170 | replacement = q; |
| 12171 | } |
| 12172 | } |
| 12173 | } |
| 12174 | if (replacement) |
| 12175 | debugf("mDNS_StopQuery_internal: Updating CRActiveQuestion to %p for cache record %s, Original question CurrentAnswers %d, new question " |
| 12176 | "CurrentAnswers %d, SuppressQuery %d" , replacement, CRDisplayString(m,rr), question->CurrentAnswers, replacement->CurrentAnswers, replacement->SuppressQuery); |
| 12177 | rr->CRActiveQuestion = replacement; // Question used to be active; new value may or may not be null |
| 12178 | if (!replacement) m->rrcache_active--; // If no longer active, decrement rrcache_active count |
| 12179 | } |
| 12180 | } |
| 12181 | |
| 12182 | // If we just deleted the question that CacheRecordAdd() or CacheRecordRmv() is about to look at, |
| 12183 | // bump its pointer forward one question. |
| 12184 | if (m->CurrentQuestion == question) |
| 12185 | { |
| 12186 | debugf("mDNS_StopQuery_internal: Just deleted the currently active question: %##s (%s)" , |
| 12187 | question->qname.c, DNSTypeName(question->qtype)); |
| 12188 | m->CurrentQuestion = question->next; |
| 12189 | } |
| 12190 | |
| 12191 | if (m->NewQuestions == question) |
| 12192 | { |
| 12193 | debugf("mDNS_StopQuery_internal: Just deleted a new question that wasn't even answered yet: %##s (%s)" , |
| 12194 | question->qname.c, DNSTypeName(question->qtype)); |
| 12195 | m->NewQuestions = question->next; |
| 12196 | } |
| 12197 | |
| 12198 | if (m->NewLocalOnlyQuestions == question) m->NewLocalOnlyQuestions = question->next; |
| 12199 | |
| 12200 | if (m->RestartQuestion == question) |
| 12201 | { |
| 12202 | LogMsg("mDNS_StopQuery_internal: Just deleted the current restart question: %##s (%s)" , |
| 12203 | question->qname.c, DNSTypeName(question->qtype)); |
| 12204 | m->RestartQuestion = question->next; |
| 12205 | } |
| 12206 | |
| 12207 | if (m->ValidationQuestion == question) |
| 12208 | { |
| 12209 | LogInfo("mDNS_StopQuery_internal: Just deleted the current Validation question: %##s (%s)" , |
| 12210 | question->qname.c, DNSTypeName(question->qtype)); |
| 12211 | m->ValidationQuestion = question->next; |
| 12212 | } |
| 12213 | |
| 12214 | // Take care not to trash question->next until *after* we've updated m->CurrentQuestion and m->NewQuestions |
| 12215 | question->next = mDNSNULL; |
| 12216 | |
| 12217 | // LogMsg("mDNS_StopQuery_internal: Question %##s (%s) removed", question->qname.c, DNSTypeName(question->qtype)); |
| 12218 | |
| 12219 | // And finally, cancel any associated GetZoneData operation that's still running. |
| 12220 | // Must not do this until last, because there's a good chance the GetZoneData question is the next in the list, |
| 12221 | // so if we delete it earlier in this routine, we could find that our "question->next" pointer above is already |
| 12222 | // invalid before we even use it. By making sure that we update m->CurrentQuestion and m->NewQuestions if necessary |
| 12223 | // *first*, then they're all ready to be updated a second time if necessary when we cancel our GetZoneData query. |
| 12224 | if (question->tcp) { DisposeTCPConn(question->tcp); question->tcp = mDNSNULL; } |
| 12225 | if (question->LocalSocket) { mDNSPlatformUDPClose(question->LocalSocket); question->LocalSocket = mDNSNULL; } |
| 12226 | if (!mDNSOpaque16IsZero(question->TargetQID) && question->LongLived) |
| 12227 | { |
| 12228 | // Scan our list to see if any more wide-area LLQs remain. If not, stop our NAT Traversal. |
| 12229 | DNSQuestion *q; |
| 12230 | for (q = m->Questions; q; q=q->next) |
| 12231 | if (!mDNSOpaque16IsZero(q->TargetQID) && q->LongLived) break; |
| 12232 | if (!q) |
| 12233 | { |
| 12234 | if (!m->LLQNAT.clientCallback) // Should never happen, but just in case... |
| 12235 | { |
| 12236 | LogMsg("mDNS_StopQuery ERROR LLQNAT.clientCallback NULL" ); |
| 12237 | } |
| 12238 | else |
| 12239 | { |
| 12240 | LogInfo("Stopping LLQNAT" ); |
| 12241 | mDNS_StopNATOperation_internal(m, &m->LLQNAT); |
| 12242 | m->LLQNAT.clientCallback = mDNSNULL; // Means LLQ NAT Traversal not running |
| 12243 | } |
| 12244 | } |
| 12245 | |
| 12246 | // If necessary, tell server it can delete this LLQ state |
| 12247 | if (question->state == LLQ_Established) |
| 12248 | { |
| 12249 | question->ReqLease = 0; |
| 12250 | sendLLQRefresh(m, question); |
| 12251 | // If we need need to make a TCP connection to cancel the LLQ, that's going to take a little while. |
| 12252 | // We clear the tcp->question backpointer so that when the TCP connection completes, it doesn't |
| 12253 | // crash trying to access our cancelled question, but we don't cancel the TCP operation itself -- |
| 12254 | // we let that run out its natural course and complete asynchronously. |
| 12255 | if (question->tcp) |
| 12256 | { |
| 12257 | question->tcp->question = mDNSNULL; |
| 12258 | question->tcp = mDNSNULL; |
| 12259 | } |
| 12260 | } |
| 12261 | #ifdef DNS_PUSH_ENABLED |
| 12262 | else if (question->dnsPushState == DNSPUSH_ESTABLISHED) |
| 12263 | { |
| 12264 | if (question->tcp) |
| 12265 | { |
| 12266 | UnSubscribeToDNSPushNotificationServer(m, q); |
| 12267 | question->tcp->question = mDNSNULL; |
| 12268 | question->tcp = mDNSNULL; |
| 12269 | } |
| 12270 | } |
| 12271 | #endif // DNS_PUSH_ENABLED |
| 12272 | #if APPLE_OSX_mDNSResponder |
| 12273 | UpdateAutoTunnelDomainStatuses(m); |
| 12274 | #endif |
| 12275 | } |
| 12276 | // wait until we send the refresh above which needs the nta |
| 12277 | if (question->nta) { CancelGetZoneData(m, question->nta); question->nta = mDNSNULL; } |
| 12278 | |
| 12279 | if (question->ValidationRequired && question->DNSSECAuthInfo) |
| 12280 | { |
| 12281 | LogInfo("mDNS_StopQuery_internal: freeing DNSSECAuthInfo %##s" , question->qname.c); |
| 12282 | question->DAIFreeCallback(m, question->DNSSECAuthInfo); |
| 12283 | question->DNSSECAuthInfo = mDNSNULL; |
| 12284 | } |
| 12285 | if (question->AnonInfo) |
| 12286 | { |
| 12287 | FreeAnonInfo(question->AnonInfo); |
| 12288 | question->AnonInfo = mDNSNULL; |
| 12289 | } |
| 12290 | #if AWD_METRICS |
| 12291 | if (question->metrics.originalQName) |
| 12292 | { |
| 12293 | mDNSPlatformMemFree(question->metrics.originalQName); |
| 12294 | question->metrics.originalQName = mDNSNULL; |
| 12295 | } |
| 12296 | #endif |
| 12297 | |
| 12298 | #if USE_DNS64 |
| 12299 | DNS64ResetState(question); |
| 12300 | #endif |
| 12301 | |
| 12302 | return(mStatus_NoError); |
| 12303 | } |
| 12304 | |
| 12305 | mDNSexport mStatus mDNS_StartQuery(mDNS *const m, DNSQuestion *const question) |
| 12306 | { |
| 12307 | mStatus status; |
| 12308 | mDNS_Lock(m); |
| 12309 | status = mDNS_StartQuery_internal(m, question); |
| 12310 | mDNS_Unlock(m); |
| 12311 | return(status); |
| 12312 | } |
| 12313 | |
| 12314 | mDNSexport mStatus mDNS_StopQuery(mDNS *const m, DNSQuestion *const question) |
| 12315 | { |
| 12316 | mStatus status; |
| 12317 | mDNS_Lock(m); |
| 12318 | status = mDNS_StopQuery_internal(m, question); |
| 12319 | mDNS_Unlock(m); |
| 12320 | return(status); |
| 12321 | } |
| 12322 | |
| 12323 | // Note that mDNS_StopQueryWithRemoves() does not currently implement the full generality of the other APIs |
| 12324 | // Specifically, question callbacks invoked as a result of this call cannot themselves make API calls. |
| 12325 | // We invoke the callback without using mDNS_DropLockBeforeCallback/mDNS_ReclaimLockAfterCallback |
| 12326 | // specifically to catch and report if the client callback does try to make API calls |
| 12327 | mDNSexport mStatus mDNS_StopQueryWithRemoves(mDNS *const m, DNSQuestion *const question) |
| 12328 | { |
| 12329 | mStatus status; |
| 12330 | DNSQuestion *qq; |
| 12331 | mDNS_Lock(m); |
| 12332 | |
| 12333 | // Check if question is new -- don't want to give remove events for a question we haven't even answered yet |
| 12334 | for (qq = m->NewQuestions; qq; qq=qq->next) if (qq == question) break; |
| 12335 | |
| 12336 | status = mDNS_StopQuery_internal(m, question); |
| 12337 | if (status == mStatus_NoError && !qq) |
| 12338 | { |
| 12339 | const CacheRecord *rr; |
| 12340 | CacheGroup *const cg = CacheGroupForName(m, question->qnamehash, &question->qname); |
| 12341 | LogInfo("Generating terminal removes for %##s (%s)" , question->qname.c, DNSTypeName(question->qtype)); |
| 12342 | for (rr = cg ? cg->members : mDNSNULL; rr; rr=rr->next) |
| 12343 | if (rr->resrec.RecordType != kDNSRecordTypePacketNegative && SameNameRecordAnswersQuestion(&rr->resrec, question)) |
| 12344 | { |
| 12345 | // Don't use mDNS_DropLockBeforeCallback() here, since we don't allow API calls |
| 12346 | if (question->QuestionCallback) |
| 12347 | question->QuestionCallback(m, question, &rr->resrec, mDNSfalse); |
| 12348 | } |
| 12349 | } |
| 12350 | mDNS_Unlock(m); |
| 12351 | return(status); |
| 12352 | } |
| 12353 | |
| 12354 | mDNSexport mStatus mDNS_Reconfirm(mDNS *const m, CacheRecord *const cr) |
| 12355 | { |
| 12356 | mStatus status; |
| 12357 | mDNS_Lock(m); |
| 12358 | status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); |
| 12359 | if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0); |
| 12360 | mDNS_Unlock(m); |
| 12361 | return(status); |
| 12362 | } |
| 12363 | |
| 12364 | mDNSexport mStatus mDNS_ReconfirmByValue(mDNS *const m, ResourceRecord *const rr) |
| 12365 | { |
| 12366 | mStatus status = mStatus_BadReferenceErr; |
| 12367 | CacheRecord *cr; |
| 12368 | mDNS_Lock(m); |
| 12369 | cr = FindIdenticalRecordInCache(m, rr); |
| 12370 | debugf("mDNS_ReconfirmByValue: %p %s" , cr, RRDisplayString(m, rr)); |
| 12371 | if (cr) status = mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); |
| 12372 | if (status == mStatus_NoError) ReconfirmAntecedents(m, cr->resrec.name, cr->resrec.namehash, 0); |
| 12373 | mDNS_Unlock(m); |
| 12374 | return(status); |
| 12375 | } |
| 12376 | |
| 12377 | mDNSlocal mStatus mDNS_StartBrowse_internal(mDNS *const m, DNSQuestion *const question, |
| 12378 | const domainname *const srv, const domainname *const domain, |
| 12379 | const mDNSu8 *anondata, const mDNSInterfaceID InterfaceID, mDNSu32 flags, |
| 12380 | mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass, |
| 12381 | mDNSQuestionCallback *Callback, void *Context) |
| 12382 | { |
| 12383 | question->InterfaceID = InterfaceID; |
| 12384 | question->flags = flags; |
| 12385 | question->Target = zeroAddr; |
| 12386 | question->qtype = kDNSType_PTR; |
| 12387 | question->qclass = kDNSClass_IN; |
| 12388 | question->LongLived = mDNStrue; |
| 12389 | question->ExpectUnique = mDNSfalse; |
| 12390 | question->ForceMCast = ForceMCast; |
| 12391 | question->ReturnIntermed = (flags & kDNSServiceFlagsReturnIntermediates) != 0; |
| 12392 | question->SuppressUnusable = mDNSfalse; |
| 12393 | question->SearchListIndex = 0; |
| 12394 | question->AppendSearchDomains = 0; |
| 12395 | question->RetryWithSearchDomains = mDNSfalse; |
| 12396 | question->TimeoutQuestion = 0; |
| 12397 | question->WakeOnResolve = 0; |
| 12398 | question->UseBackgroundTrafficClass = useBackgroundTrafficClass; |
| 12399 | question->ValidationRequired = 0; |
| 12400 | question->ValidatingResponse = 0; |
| 12401 | question->ProxyQuestion = 0; |
| 12402 | question->qnameOrig = mDNSNULL; |
| 12403 | question->AnonInfo = mDNSNULL; |
| 12404 | question->QuestionCallback = Callback; |
| 12405 | question->QuestionContext = Context; |
| 12406 | |
| 12407 | if (!ConstructServiceName(&question->qname, mDNSNULL, srv, domain)) |
| 12408 | return(mStatus_BadParamErr); |
| 12409 | |
| 12410 | if (anondata) |
| 12411 | { |
| 12412 | question->AnonInfo = AllocateAnonInfo(&question->qname, anondata, mDNSPlatformStrLen(anondata), mDNSNULL); |
| 12413 | if (!question->AnonInfo) |
| 12414 | return(mStatus_BadParamErr); |
| 12415 | } |
| 12416 | |
| 12417 | return(mDNS_StartQuery_internal(m, question)); |
| 12418 | } |
| 12419 | |
| 12420 | mDNSexport mStatus mDNS_StartBrowse(mDNS *const m, DNSQuestion *const question, |
| 12421 | const domainname *const srv, const domainname *const domain, |
| 12422 | const mDNSu8 *anondata, const mDNSInterfaceID InterfaceID, mDNSu32 flags, |
| 12423 | mDNSBool ForceMCast, mDNSBool useBackgroundTrafficClass, |
| 12424 | mDNSQuestionCallback *Callback, void *Context) |
| 12425 | { |
| 12426 | mStatus status; |
| 12427 | mDNS_Lock(m); |
| 12428 | status = mDNS_StartBrowse_internal(m, question, srv, domain, anondata, InterfaceID, flags, ForceMCast, useBackgroundTrafficClass, Callback, Context); |
| 12429 | mDNS_Unlock(m); |
| 12430 | return(status); |
| 12431 | } |
| 12432 | |
| 12433 | |
| 12434 | mDNSexport mStatus mDNS_GetDomains(mDNS *const m, DNSQuestion *const question, mDNS_DomainType DomainType, const domainname *dom, |
| 12435 | const mDNSInterfaceID InterfaceID, mDNSQuestionCallback *Callback, void *Context) |
| 12436 | { |
| 12437 | question->InterfaceID = InterfaceID; |
| 12438 | question->flags = 0; |
| 12439 | question->Target = zeroAddr; |
| 12440 | question->qtype = kDNSType_PTR; |
| 12441 | question->qclass = kDNSClass_IN; |
| 12442 | question->LongLived = mDNSfalse; |
| 12443 | question->ExpectUnique = mDNSfalse; |
| 12444 | question->ForceMCast = mDNSfalse; |
| 12445 | question->ReturnIntermed = mDNSfalse; |
| 12446 | question->SuppressUnusable = mDNSfalse; |
| 12447 | question->SearchListIndex = 0; |
| 12448 | question->AppendSearchDomains = 0; |
| 12449 | question->RetryWithSearchDomains = mDNSfalse; |
| 12450 | question->TimeoutQuestion = 0; |
| 12451 | question->WakeOnResolve = 0; |
| 12452 | question->UseBackgroundTrafficClass = mDNSfalse; |
| 12453 | question->ValidationRequired = 0; |
| 12454 | question->ValidatingResponse = 0; |
| 12455 | question->ProxyQuestion = 0; |
| 12456 | question->qnameOrig = mDNSNULL; |
| 12457 | question->AnonInfo = mDNSNULL; |
| 12458 | question->pid = mDNSPlatformGetPID(); |
| 12459 | question->euid = 0; |
| 12460 | question->QuestionCallback = Callback; |
| 12461 | question->QuestionContext = Context; |
| 12462 | if (DomainType > mDNS_DomainTypeMax) return(mStatus_BadParamErr); |
| 12463 | if (!MakeDomainNameFromDNSNameString(&question->qname, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr); |
| 12464 | if (!dom) dom = &localdomain; |
| 12465 | if (!AppendDomainName(&question->qname, dom)) return(mStatus_BadParamErr); |
| 12466 | return(mDNS_StartQuery(m, question)); |
| 12467 | } |
| 12468 | |
| 12469 | // *************************************************************************** |
| 12470 | #if COMPILER_LIKES_PRAGMA_MARK |
| 12471 | #pragma mark - |
| 12472 | #pragma mark - Responder Functions |
| 12473 | #endif |
| 12474 | |
| 12475 | mDNSexport mStatus mDNS_Register(mDNS *const m, AuthRecord *const rr) |
| 12476 | { |
| 12477 | mStatus status; |
| 12478 | mDNS_Lock(m); |
| 12479 | status = mDNS_Register_internal(m, rr); |
| 12480 | mDNS_Unlock(m); |
| 12481 | return(status); |
| 12482 | } |
| 12483 | |
| 12484 | mDNSexport mStatus mDNS_Update(mDNS *const m, AuthRecord *const rr, mDNSu32 newttl, |
| 12485 | const mDNSu16 newrdlength, RData *const newrdata, mDNSRecordUpdateCallback *Callback) |
| 12486 | { |
| 12487 | if (!ValidateRData(rr->resrec.rrtype, newrdlength, newrdata)) |
| 12488 | { |
| 12489 | LogMsg("Attempt to update record with invalid rdata: %s" , GetRRDisplayString_rdb(&rr->resrec, &newrdata->u, m->MsgBuffer)); |
| 12490 | return(mStatus_Invalid); |
| 12491 | } |
| 12492 | |
| 12493 | mDNS_Lock(m); |
| 12494 | |
| 12495 | // If TTL is unspecified, leave TTL unchanged |
| 12496 | if (newttl == 0) newttl = rr->resrec.rroriginalttl; |
| 12497 | |
| 12498 | // If we already have an update queued up which has not gone through yet, give the client a chance to free that memory |
| 12499 | if (rr->NewRData) |
| 12500 | { |
| 12501 | RData *n = rr->NewRData; |
| 12502 | rr->NewRData = mDNSNULL; // Clear the NewRData pointer ... |
| 12503 | if (rr->UpdateCallback) |
| 12504 | rr->UpdateCallback(m, rr, n, rr->newrdlength); // ...and let the client free this memory, if necessary |
| 12505 | } |
| 12506 | |
| 12507 | rr->NewRData = newrdata; |
| 12508 | rr->newrdlength = newrdlength; |
| 12509 | rr->UpdateCallback = Callback; |
| 12510 | |
| 12511 | #ifndef UNICAST_DISABLED |
| 12512 | if (rr->ARType != AuthRecordLocalOnly && rr->ARType != AuthRecordP2P && !IsLocalDomain(rr->resrec.name)) |
| 12513 | { |
| 12514 | mStatus status = uDNS_UpdateRecord(m, rr); |
| 12515 | // The caller frees the memory on error, don't retain stale pointers |
| 12516 | if (status != mStatus_NoError) { rr->NewRData = mDNSNULL; rr->newrdlength = 0; } |
| 12517 | mDNS_Unlock(m); |
| 12518 | return(status); |
| 12519 | } |
| 12520 | #endif |
| 12521 | |
| 12522 | if (RRLocalOnly(rr) || (rr->resrec.rroriginalttl == newttl && |
| 12523 | rr->resrec.rdlength == newrdlength && mDNSPlatformMemSame(rr->resrec.rdata->u.data, newrdata->u.data, newrdlength))) |
| 12524 | CompleteRDataUpdate(m, rr); |
| 12525 | else |
| 12526 | { |
| 12527 | rr->AnnounceCount = InitialAnnounceCount; |
| 12528 | InitializeLastAPTime(m, rr); |
| 12529 | while (rr->NextUpdateCredit && m->timenow - rr->NextUpdateCredit >= 0) GrantUpdateCredit(rr); |
| 12530 | if (!rr->UpdateBlocked && rr->UpdateCredits) rr->UpdateCredits--; |
| 12531 | if (!rr->NextUpdateCredit) rr->NextUpdateCredit = NonZeroTime(m->timenow + kUpdateCreditRefreshInterval); |
| 12532 | if (rr->AnnounceCount > rr->UpdateCredits + 1) rr->AnnounceCount = (mDNSu8)(rr->UpdateCredits + 1); |
| 12533 | if (rr->UpdateCredits <= 5) |
| 12534 | { |
| 12535 | mDNSu32 delay = 6 - rr->UpdateCredits; // Delay 1 second, then 2, then 3, etc. up to 6 seconds maximum |
| 12536 | if (!rr->UpdateBlocked) rr->UpdateBlocked = NonZeroTime(m->timenow + (mDNSs32)delay * mDNSPlatformOneSecond); |
| 12537 | rr->ThisAPInterval *= 4; |
| 12538 | rr->LastAPTime = rr->UpdateBlocked - rr->ThisAPInterval; |
| 12539 | LogMsg("Excessive update rate for %##s; delaying announcement by %ld second%s" , |
| 12540 | rr->resrec.name->c, delay, delay > 1 ? "s" : "" ); |
| 12541 | } |
| 12542 | rr->resrec.rroriginalttl = newttl; |
| 12543 | } |
| 12544 | |
| 12545 | mDNS_Unlock(m); |
| 12546 | return(mStatus_NoError); |
| 12547 | } |
| 12548 | |
| 12549 | // Note: mDNS_Deregister calls mDNS_Deregister_internal which can call a user callback, which may change |
| 12550 | // the record list and/or question list. |
| 12551 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 12552 | mDNSexport mStatus mDNS_Deregister(mDNS *const m, AuthRecord *const rr) |
| 12553 | { |
| 12554 | mStatus status; |
| 12555 | mDNS_Lock(m); |
| 12556 | status = mDNS_Deregister_internal(m, rr, mDNS_Dereg_normal); |
| 12557 | mDNS_Unlock(m); |
| 12558 | return(status); |
| 12559 | } |
| 12560 | |
| 12561 | // Circular reference: AdvertiseInterface references mDNS_HostNameCallback, which calls mDNS_SetFQDN, which call AdvertiseInterface |
| 12562 | mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result); |
| 12563 | |
| 12564 | mDNSlocal NetworkInterfaceInfo *FindFirstAdvertisedInterface(mDNS *const m) |
| 12565 | { |
| 12566 | NetworkInterfaceInfo *intf; |
| 12567 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 12568 | if (intf->Advertise) break; |
| 12569 | return(intf); |
| 12570 | } |
| 12571 | |
| 12572 | // The parameter "set" here refers to the set of AuthRecords used to advertise this interface. |
| 12573 | // (It's a set of records, not a set of interfaces.) |
| 12574 | mDNSlocal void AdvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set) |
| 12575 | { |
| 12576 | char buffer[MAX_REVERSE_MAPPING_NAME]; |
| 12577 | NetworkInterfaceInfo *primary; |
| 12578 | mDNSu8 recordType; |
| 12579 | |
| 12580 | if (m->AutoTargetServices == 0) |
| 12581 | { |
| 12582 | LogInfo("AdvertiseInterface: Returning due to AutoTargetServices zero for %s" , set->ifname); |
| 12583 | return; |
| 12584 | } |
| 12585 | |
| 12586 | primary = FindFirstAdvertisedInterface(m); |
| 12587 | if (!primary) primary = set; // If no existing advertised interface, this new NetworkInterfaceInfo becomes our new primary |
| 12588 | // We should never have primary be NULL, because even if there is |
| 12589 | // no other interface yet, we should always find ourself in the list. |
| 12590 | |
| 12591 | // If interface is marked as a direct link, we can assume the address record is unique |
| 12592 | // and does not need to go through the probe phase of the probe/announce packet sequence. |
| 12593 | recordType = (set->DirectLink ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique); |
| 12594 | |
| 12595 | if (set->DirectLink) |
| 12596 | LogInfo("AdvertiseInterface: Marking address record as kDNSRecordTypeKnownUnique for %s" , set->ifname); |
| 12597 | |
| 12598 | // Send dynamic update for non-linklocal IPv4 Addresses |
| 12599 | mDNS_SetupResourceRecord(&set->RR_A, mDNSNULL, set->InterfaceID, kDNSType_A, kHostNameTTL, recordType, AuthRecordAny, mDNS_HostNameCallback, set); |
| 12600 | mDNS_SetupResourceRecord(&set->RR_PTR, mDNSNULL, set->InterfaceID, kDNSType_PTR, kHostNameTTL, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 12601 | mDNS_SetupResourceRecord(&set->RR_HINFO, mDNSNULL, set->InterfaceID, kDNSType_HINFO, kHostNameTTL, kDNSRecordTypeUnique, AuthRecordAny, mDNSNULL, mDNSNULL); |
| 12602 | |
| 12603 | #if ANSWER_REMOTE_HOSTNAME_QUERIES |
| 12604 | set->RR_A.AllowRemoteQuery = mDNStrue; |
| 12605 | set->RR_PTR.AllowRemoteQuery = mDNStrue; |
| 12606 | set->RR_HINFO.AllowRemoteQuery = mDNStrue; |
| 12607 | #endif |
| 12608 | // 1. Set up Address record to map from host name ("foo.local.") to IP address |
| 12609 | // 2. Set up reverse-lookup PTR record to map from our address back to our host name |
| 12610 | AssignDomainName(&set->RR_A.namestorage, &m->MulticastHostname); |
| 12611 | if (set->ip.type == mDNSAddrType_IPv4) |
| 12612 | { |
| 12613 | set->RR_A.resrec.rrtype = kDNSType_A; |
| 12614 | set->RR_A.resrec.rdata->u.ipv4 = set->ip.ip.v4; |
| 12615 | // Note: This is reverse order compared to a normal dotted-decimal IP address, so we can't use our customary "%.4a" format code |
| 12616 | mDNS_snprintf(buffer, sizeof(buffer), "%d.%d.%d.%d.in-addr.arpa." , |
| 12617 | set->ip.ip.v4.b[3], set->ip.ip.v4.b[2], set->ip.ip.v4.b[1], set->ip.ip.v4.b[0]); |
| 12618 | } |
| 12619 | else if (set->ip.type == mDNSAddrType_IPv6) |
| 12620 | { |
| 12621 | int i; |
| 12622 | set->RR_A.resrec.rrtype = kDNSType_AAAA; |
| 12623 | set->RR_A.resrec.rdata->u.ipv6 = set->ip.ip.v6; |
| 12624 | for (i = 0; i < 16; i++) |
| 12625 | { |
| 12626 | static const char hexValues[] = "0123456789ABCDEF" ; |
| 12627 | buffer[i * 4 ] = hexValues[set->ip.ip.v6.b[15 - i] & 0x0F]; |
| 12628 | buffer[i * 4 + 1] = '.'; |
| 12629 | buffer[i * 4 + 2] = hexValues[set->ip.ip.v6.b[15 - i] >> 4]; |
| 12630 | buffer[i * 4 + 3] = '.'; |
| 12631 | } |
| 12632 | mDNS_snprintf(&buffer[64], sizeof(buffer)-64, "ip6.arpa." ); |
| 12633 | } |
| 12634 | |
| 12635 | MakeDomainNameFromDNSNameString(&set->RR_PTR.namestorage, buffer); |
| 12636 | set->RR_PTR.AutoTarget = Target_AutoHost; // Tell mDNS that the target of this PTR is to be kept in sync with our host name |
| 12637 | set->RR_PTR.ForceMCast = mDNStrue; // This PTR points to our dot-local name, so don't ever try to write it into a uDNS server |
| 12638 | |
| 12639 | set->RR_A.RRSet = &primary->RR_A; // May refer to self |
| 12640 | |
| 12641 | mDNS_Register_internal(m, &set->RR_A); |
| 12642 | mDNS_Register_internal(m, &set->RR_PTR); |
| 12643 | |
| 12644 | #if APPLE_OSX_mDNSResponder |
| 12645 | // must be after the mDNS_Register_internal() calls so that records have complete rdata fields, etc |
| 12646 | D2D_start_advertising_interface(set); |
| 12647 | #endif // APPLE_OSX_mDNSResponder |
| 12648 | |
| 12649 | if (!NO_HINFO && m->HIHardware.c[0] > 0 && m->HISoftware.c[0] > 0 && m->HIHardware.c[0] + m->HISoftware.c[0] <= 254) |
| 12650 | { |
| 12651 | mDNSu8 *p = set->RR_HINFO.resrec.rdata->u.data; |
| 12652 | AssignDomainName(&set->RR_HINFO.namestorage, &m->MulticastHostname); |
| 12653 | set->RR_HINFO.DependentOn = &set->RR_A; |
| 12654 | mDNSPlatformMemCopy(p, &m->HIHardware, 1 + (mDNSu32)m->HIHardware.c[0]); |
| 12655 | p += 1 + (int)p[0]; |
| 12656 | mDNSPlatformMemCopy(p, &m->HISoftware, 1 + (mDNSu32)m->HISoftware.c[0]); |
| 12657 | mDNS_Register_internal(m, &set->RR_HINFO); |
| 12658 | } |
| 12659 | else |
| 12660 | { |
| 12661 | debugf("Not creating HINFO record: platform support layer provided no information" ); |
| 12662 | set->RR_HINFO.resrec.RecordType = kDNSRecordTypeUnregistered; |
| 12663 | } |
| 12664 | } |
| 12665 | |
| 12666 | mDNSlocal void DeadvertiseInterface(mDNS *const m, NetworkInterfaceInfo *set) |
| 12667 | { |
| 12668 | if (m->AutoTargetServices == 0) |
| 12669 | { |
| 12670 | LogInfo("DeadvertiseInterface: Returning due to AutoTargetServices zero for %s" , set->ifname); |
| 12671 | return; |
| 12672 | } |
| 12673 | |
| 12674 | #if APPLE_OSX_mDNSResponder |
| 12675 | D2D_stop_advertising_interface(set); |
| 12676 | #endif // APPLE_OSX_mDNSResponder |
| 12677 | |
| 12678 | // Unregister these records. |
| 12679 | // When doing the mDNS_Exit processing, we first call DeadvertiseInterface for each interface, so by the time the platform |
| 12680 | // support layer gets to call mDNS_DeregisterInterface, the address and PTR records have already been deregistered for it. |
| 12681 | // Also, in the event of a name conflict, one or more of our records will have been forcibly deregistered. |
| 12682 | // To avoid unnecessary and misleading warning messages, we check the RecordType before calling mDNS_Deregister_internal(). |
| 12683 | if (set->RR_A .resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_A, mDNS_Dereg_normal); |
| 12684 | if (set->RR_PTR .resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_PTR, mDNS_Dereg_normal); |
| 12685 | if (set->RR_HINFO.resrec.RecordType) mDNS_Deregister_internal(m, &set->RR_HINFO, mDNS_Dereg_normal); |
| 12686 | } |
| 12687 | |
| 12688 | mDNSlocal void AdvertiseAllInterfaceRecords(mDNS *const m) |
| 12689 | { |
| 12690 | NetworkInterfaceInfo *intf; |
| 12691 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 12692 | { |
| 12693 | if (intf->Advertise) |
| 12694 | { |
| 12695 | LogInfo("AdvertiseInterface: Advertising for ifname %s" , intf->ifname); |
| 12696 | AdvertiseInterface(m, intf); |
| 12697 | } |
| 12698 | } |
| 12699 | } |
| 12700 | |
| 12701 | mDNSlocal void DeadvertiseAllInterfaceRecords(mDNS *const m) |
| 12702 | { |
| 12703 | NetworkInterfaceInfo *intf; |
| 12704 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 12705 | { |
| 12706 | if (intf->Advertise) |
| 12707 | { |
| 12708 | LogInfo("DeadvertiseInterface: Deadvertising for ifname %s" , intf->ifname); |
| 12709 | DeadvertiseInterface(m, intf); |
| 12710 | } |
| 12711 | } |
| 12712 | } |
| 12713 | |
| 12714 | // Change target host name for record. |
| 12715 | mDNSlocal void UpdateTargetHostName(mDNS *const m, AuthRecord *const rr) |
| 12716 | { |
| 12717 | #if APPLE_OSX_mDNSResponder |
| 12718 | // If this record was also registered with any D2D plugins, stop advertising |
| 12719 | // the version with the old host name. |
| 12720 | D2D_stop_advertising_record(rr); |
| 12721 | #endif |
| 12722 | |
| 12723 | SetTargetToHostName(m, rr); |
| 12724 | |
| 12725 | #if APPLE_OSX_mDNSResponder |
| 12726 | // Advertise the record with the updated host name with the D2D plugins if appropriate. |
| 12727 | D2D_start_advertising_record(rr); |
| 12728 | #endif |
| 12729 | } |
| 12730 | |
| 12731 | mDNSexport void mDNS_SetFQDN(mDNS *const m) |
| 12732 | { |
| 12733 | domainname newmname; |
| 12734 | AuthRecord *rr; |
| 12735 | newmname.c[0] = 0; |
| 12736 | |
| 12737 | if (!AppendDomainLabel(&newmname, &m->hostlabel)) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname" ); return; } |
| 12738 | if (!AppendLiteralLabelString(&newmname, "local" )) { LogMsg("ERROR: mDNS_SetFQDN: Cannot create MulticastHostname" ); return; } |
| 12739 | |
| 12740 | mDNS_Lock(m); |
| 12741 | |
| 12742 | if (SameDomainNameCS(&m->MulticastHostname, &newmname)) debugf("mDNS_SetFQDN - hostname unchanged" ); |
| 12743 | else |
| 12744 | { |
| 12745 | AssignDomainName(&m->MulticastHostname, &newmname); |
| 12746 | DeadvertiseAllInterfaceRecords(m); |
| 12747 | AdvertiseAllInterfaceRecords(m); |
| 12748 | } |
| 12749 | |
| 12750 | // 3. Make sure that any AutoTarget SRV records (and the like) get updated |
| 12751 | for (rr = m->ResourceRecords; rr; rr=rr->next) if (rr->AutoTarget) UpdateTargetHostName(m, rr); |
| 12752 | for (rr = m->DuplicateRecords; rr; rr=rr->next) if (rr->AutoTarget) UpdateTargetHostName(m, rr); |
| 12753 | |
| 12754 | mDNS_Unlock(m); |
| 12755 | } |
| 12756 | |
| 12757 | mDNSlocal void mDNS_HostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result) |
| 12758 | { |
| 12759 | (void)rr; // Unused parameter |
| 12760 | |
| 12761 | #if MDNS_DEBUGMSGS |
| 12762 | { |
| 12763 | char *msg = "Unknown result" ; |
| 12764 | if (result == mStatus_NoError) msg = "Name registered" ; |
| 12765 | else if (result == mStatus_NameConflict) msg = "Name conflict" ; |
| 12766 | debugf("mDNS_HostNameCallback: %##s (%s) %s (%ld)" , rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result); |
| 12767 | } |
| 12768 | #endif |
| 12769 | |
| 12770 | if (result == mStatus_NoError) |
| 12771 | { |
| 12772 | // Notify the client that the host name is successfully registered |
| 12773 | if (m->MainCallback) |
| 12774 | m->MainCallback(m, mStatus_NoError); |
| 12775 | } |
| 12776 | else if (result == mStatus_NameConflict) |
| 12777 | { |
| 12778 | domainlabel oldlabel = m->hostlabel; |
| 12779 | |
| 12780 | // 1. First give the client callback a chance to pick a new name |
| 12781 | if (m->MainCallback) |
| 12782 | m->MainCallback(m, mStatus_NameConflict); |
| 12783 | |
| 12784 | // 2. If the client callback didn't do it, add (or increment) an index ourselves |
| 12785 | // This needs to be case-INSENSITIVE compare, because we need to know that the name has been changed so as to |
| 12786 | // remedy the conflict, and a name that differs only in capitalization will just suffer the exact same conflict again. |
| 12787 | if (SameDomainLabel(m->hostlabel.c, oldlabel.c)) |
| 12788 | IncrementLabelSuffix(&m->hostlabel, mDNSfalse); |
| 12789 | |
| 12790 | // 3. Generate the FQDNs from the hostlabel, |
| 12791 | // and make sure all SRV records, etc., are updated to reference our new hostname |
| 12792 | mDNS_SetFQDN(m); |
| 12793 | LogMsg("Local Hostname %#s.local already in use; will try %#s.local instead" , oldlabel.c, m->hostlabel.c); |
| 12794 | } |
| 12795 | else if (result == mStatus_MemFree) |
| 12796 | { |
| 12797 | // .local hostnames do not require goodbyes - we ignore the MemFree (which is sent directly by |
| 12798 | // mDNS_Deregister_internal), and allow the caller to deallocate immediately following mDNS_DeadvertiseInterface |
| 12799 | debugf("mDNS_HostNameCallback: MemFree (ignored)" ); |
| 12800 | } |
| 12801 | else |
| 12802 | LogMsg("mDNS_HostNameCallback: Unknown error %d for registration of record %s" , result, rr->resrec.name->c); |
| 12803 | } |
| 12804 | |
| 12805 | mDNSlocal void UpdateInterfaceProtocols(mDNS *const m, NetworkInterfaceInfo *active) |
| 12806 | { |
| 12807 | NetworkInterfaceInfo *intf; |
| 12808 | active->IPv4Available = mDNSfalse; |
| 12809 | active->IPv6Available = mDNSfalse; |
| 12810 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 12811 | if (intf->InterfaceID == active->InterfaceID) |
| 12812 | { |
| 12813 | if (intf->ip.type == mDNSAddrType_IPv4 && intf->McastTxRx) active->IPv4Available = mDNStrue; |
| 12814 | if (intf->ip.type == mDNSAddrType_IPv6 && intf->McastTxRx) active->IPv6Available = mDNStrue; |
| 12815 | } |
| 12816 | } |
| 12817 | |
| 12818 | mDNSlocal void RestartRecordGetZoneData(mDNS * const m) |
| 12819 | { |
| 12820 | AuthRecord *rr; |
| 12821 | LogInfo("RestartRecordGetZoneData: ResourceRecords" ); |
| 12822 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 12823 | if (AuthRecord_uDNS(rr) && rr->state != regState_NoTarget) |
| 12824 | { |
| 12825 | debugf("RestartRecordGetZoneData: StartGetZoneData for %##s" , rr->resrec.name->c); |
| 12826 | // Zero out the updateid so that if we have a pending response from the server, it won't |
| 12827 | // be accepted as a valid response. If we accept the response, we might free the new "nta" |
| 12828 | if (rr->nta) { rr->updateid = zeroID; CancelGetZoneData(m, rr->nta); } |
| 12829 | rr->nta = StartGetZoneData(m, rr->resrec.name, ZoneServiceUpdate, RecordRegistrationGotZoneData, rr); |
| 12830 | } |
| 12831 | } |
| 12832 | |
| 12833 | mDNSlocal void InitializeNetWakeState(mDNS *const m, NetworkInterfaceInfo *set) |
| 12834 | { |
| 12835 | int i; |
| 12836 | // We initialize ThisQInterval to -1 indicating that the question has not been started |
| 12837 | // yet. If the question (browse) is started later during interface registration, it will |
| 12838 | // be stopped during interface deregistration. We can't sanity check to see if the |
| 12839 | // question has been stopped or not before initializing it to -1 because we need to |
| 12840 | // initialize it to -1 the very first time. |
| 12841 | |
| 12842 | set->NetWakeBrowse.ThisQInterval = -1; |
| 12843 | for (i=0; i<3; i++) |
| 12844 | { |
| 12845 | set->NetWakeResolve[i].ThisQInterval = -1; |
| 12846 | set->SPSAddr[i].type = mDNSAddrType_None; |
| 12847 | } |
| 12848 | set->NextSPSAttempt = -1; |
| 12849 | set->NextSPSAttemptTime = m->timenow; |
| 12850 | } |
| 12851 | |
| 12852 | mDNSexport void mDNS_ActivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set) |
| 12853 | { |
| 12854 | NetworkInterfaceInfo *p = m->HostInterfaces; |
| 12855 | while (p && p != set) p=p->next; |
| 12856 | if (!p) { LogMsg("mDNS_ActivateNetWake_internal: NetworkInterfaceInfo %p not found in active list" , set); return; } |
| 12857 | |
| 12858 | if (set->InterfaceActive) |
| 12859 | { |
| 12860 | LogSPS("ActivateNetWake for %s (%#a)" , set->ifname, &set->ip); |
| 12861 | mDNS_StartBrowse_internal(m, &set->NetWakeBrowse, &SleepProxyServiceType, &localdomain, mDNSNULL, set->InterfaceID, 0, mDNSfalse, mDNSfalse, m->SPSBrowseCallback, set); |
| 12862 | } |
| 12863 | } |
| 12864 | |
| 12865 | mDNSexport void mDNS_DeactivateNetWake_internal(mDNS *const m, NetworkInterfaceInfo *set) |
| 12866 | { |
| 12867 | NetworkInterfaceInfo *p = m->HostInterfaces; |
| 12868 | while (p && p != set) p=p->next; |
| 12869 | if (!p) { LogMsg("mDNS_DeactivateNetWake_internal: NetworkInterfaceInfo %p not found in active list" , set); return; } |
| 12870 | |
| 12871 | // Note: We start the browse only if the interface is NetWake capable and we use this to |
| 12872 | // stop the resolves also. Hence, the resolves should not be started without the browse |
| 12873 | // being started i.e, resolves should not happen unless NetWake capable which is |
| 12874 | // guaranteed by BeginSleepProcessing. |
| 12875 | if (set->NetWakeBrowse.ThisQInterval >= 0) |
| 12876 | { |
| 12877 | int i; |
| 12878 | LogSPS("DeactivateNetWake for %s (%#a)" , set->ifname, &set->ip); |
| 12879 | |
| 12880 | // Stop our browse and resolve operations |
| 12881 | mDNS_StopQuery_internal(m, &set->NetWakeBrowse); |
| 12882 | for (i=0; i<3; i++) if (set->NetWakeResolve[i].ThisQInterval >= 0) mDNS_StopQuery_internal(m, &set->NetWakeResolve[i]); |
| 12883 | |
| 12884 | // Make special call to the browse callback to let it know it can to remove all records for this interface |
| 12885 | if (m->SPSBrowseCallback) |
| 12886 | { |
| 12887 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 12888 | m->SPSBrowseCallback(m, &set->NetWakeBrowse, mDNSNULL, mDNSfalse); |
| 12889 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 12890 | } |
| 12891 | |
| 12892 | // Reset our variables back to initial state, so we're ready for when NetWake is turned back on |
| 12893 | // (includes resetting NetWakeBrowse.ThisQInterval back to -1) |
| 12894 | InitializeNetWakeState(m, set); |
| 12895 | } |
| 12896 | } |
| 12897 | |
| 12898 | mDNSexport mStatus mDNS_RegisterInterface(mDNS *const m, NetworkInterfaceInfo *set, InterfaceActivationSpeed activationSpeed) |
| 12899 | { |
| 12900 | AuthRecord *rr; |
| 12901 | mDNSBool FirstOfType = mDNStrue; |
| 12902 | NetworkInterfaceInfo **p = &m->HostInterfaces; |
| 12903 | |
| 12904 | if (!set->InterfaceID) |
| 12905 | { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with zero InterfaceID" , &set->ip); return(mStatus_Invalid); } |
| 12906 | |
| 12907 | if (!mDNSAddressIsValidNonZero(&set->mask)) |
| 12908 | { LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo %#a with invalid mask %#a" , &set->ip, &set->mask); return(mStatus_Invalid); } |
| 12909 | |
| 12910 | mDNS_Lock(m); |
| 12911 | |
| 12912 | // Assume this interface will be active now, unless we find a duplicate already in the list |
| 12913 | set->InterfaceActive = mDNStrue; |
| 12914 | set->IPv4Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx); |
| 12915 | set->IPv6Available = (mDNSu8)(set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx); |
| 12916 | |
| 12917 | InitializeNetWakeState(m, set); |
| 12918 | |
| 12919 | // Scan list to see if this InterfaceID is already represented |
| 12920 | while (*p) |
| 12921 | { |
| 12922 | if (*p == set) |
| 12923 | { |
| 12924 | LogMsg("mDNS_RegisterInterface: Error! Tried to register a NetworkInterfaceInfo that's already in the list" ); |
| 12925 | mDNS_Unlock(m); |
| 12926 | return(mStatus_AlreadyRegistered); |
| 12927 | } |
| 12928 | |
| 12929 | if ((*p)->InterfaceID == set->InterfaceID) |
| 12930 | { |
| 12931 | // This InterfaceID already represented by a different interface in the list, so mark this instance inactive for now |
| 12932 | set->InterfaceActive = mDNSfalse; |
| 12933 | if (set->ip.type == (*p)->ip.type) FirstOfType = mDNSfalse; |
| 12934 | if (set->ip.type == mDNSAddrType_IPv4 && set->McastTxRx) (*p)->IPv4Available = mDNStrue; |
| 12935 | if (set->ip.type == mDNSAddrType_IPv6 && set->McastTxRx) (*p)->IPv6Available = mDNStrue; |
| 12936 | } |
| 12937 | |
| 12938 | p=&(*p)->next; |
| 12939 | } |
| 12940 | |
| 12941 | set->next = mDNSNULL; |
| 12942 | *p = set; |
| 12943 | |
| 12944 | if (set->Advertise) |
| 12945 | AdvertiseInterface(m, set); |
| 12946 | |
| 12947 | LogInfo("mDNS_RegisterInterface: InterfaceID %d %s (%#a) %s" , |
| 12948 | IID(set->InterfaceID), set->ifname, &set->ip, |
| 12949 | set->InterfaceActive ? |
| 12950 | "not represented in list; marking active and retriggering queries" : |
| 12951 | "already represented in list; marking inactive for now" ); |
| 12952 | |
| 12953 | if (set->NetWake) mDNS_ActivateNetWake_internal(m, set); |
| 12954 | |
| 12955 | // In early versions of OS X the IPv6 address remains on an interface even when the interface is turned off, |
| 12956 | // giving the false impression that there's an active representative of this interface when there really isn't. |
| 12957 | // Therefore, when registering an interface, we want to re-trigger our questions and re-probe our Resource Records, |
| 12958 | // even if we believe that we previously had an active representative of this interface. |
| 12959 | if (set->McastTxRx && (FirstOfType || set->InterfaceActive)) |
| 12960 | { |
| 12961 | DNSQuestion *q; |
| 12962 | // Normally, after an interface comes up, we pause half a second before beginning probing. |
| 12963 | // This is to guard against cases where there's rapid interface changes, where we could be confused by |
| 12964 | // seeing packets we ourselves sent just moments ago (perhaps when this interface had a different address) |
| 12965 | // which are then echoed back after a short delay by some Ethernet switches and some 802.11 base stations. |
| 12966 | // We don't want to do a probe, and then see a stale echo of an announcement we ourselves sent, |
| 12967 | // and think it's a conflicting answer to our probe. |
| 12968 | // In the case of a flapping interface, we pause for five seconds, and reduce the announcement count to one packet. |
| 12969 | mDNSs32 probedelay; |
| 12970 | mDNSu8 numannounce; |
| 12971 | switch (activationSpeed) |
| 12972 | { |
| 12973 | case FastActivation: |
| 12974 | probedelay = (mDNSs32)0; |
| 12975 | numannounce = InitialAnnounceCount; |
| 12976 | LogMsg("mDNS_RegisterInterface: Using fast activation for DirectLink interface %s (%#a)" , set->ifname, &set->ip); |
| 12977 | break; |
| 12978 | |
| 12979 | case SlowActivation: |
| 12980 | probedelay = mDNSPlatformOneSecond * 5; |
| 12981 | numannounce = (mDNSu8)1; |
| 12982 | LogMsg("mDNS_RegisterInterface: Frequent transitions for interface %s (%#a), doing slow activation" , set->ifname, &set->ip); |
| 12983 | m->mDNSStats.InterfaceUpFlap++; |
| 12984 | break; |
| 12985 | |
| 12986 | case NormalActivation: |
| 12987 | default: |
| 12988 | probedelay = mDNSPlatformOneSecond / 2; |
| 12989 | numannounce = InitialAnnounceCount; |
| 12990 | break; |
| 12991 | } |
| 12992 | |
| 12993 | LogInfo("mDNS_RegisterInterface: %s (%#a) probedelay %d" , set->ifname, &set->ip, probedelay); |
| 12994 | |
| 12995 | // No probe or sending suppression on DirectLink type interfaces. |
| 12996 | if (activationSpeed == FastActivation) |
| 12997 | { |
| 12998 | m->SuppressSending = 0; |
| 12999 | m->SuppressProbes = 0; |
| 13000 | } |
| 13001 | else |
| 13002 | { |
| 13003 | // Use a small amount of randomness: |
| 13004 | // In the case of a network administrator turning on an Ethernet hub so that all the |
| 13005 | // connected machines establish link at exactly the same time, we don't want them all |
| 13006 | // to go and hit the network with identical queries at exactly the same moment. |
| 13007 | // We set a random delay of up to InitialQuestionInterval (1/3 second). |
| 13008 | // We must *never* set m->SuppressSending to more than that (or set it repeatedly in a way |
| 13009 | // that causes mDNSResponder to remain in a prolonged state of SuppressSending, because |
| 13010 | // suppressing packet sending for more than about 1/3 second can cause protocol correctness |
| 13011 | // to start to break down (e.g. we don't answer probes fast enough, and get name conflicts). |
| 13012 | // See <rdar://problem/4073853> mDNS: m->SuppressSending set too enthusiastically |
| 13013 | if (!m->SuppressSending) m->SuppressSending = m->timenow + (mDNSs32)mDNSRandom((mDNSu32)InitialQuestionInterval); |
| 13014 | |
| 13015 | if (m->SuppressProbes == 0 || |
| 13016 | m->SuppressProbes - NonZeroTime(m->timenow + probedelay) < 0) |
| 13017 | m->SuppressProbes = NonZeroTime(m->timenow + probedelay); |
| 13018 | } |
| 13019 | |
| 13020 | // Include OWNER option in packets for 60 seconds after connecting to the network. Setting |
| 13021 | // it here also handles the wake up case as the network link comes UP after waking causing |
| 13022 | // us to reconnect to the network. If we do this as part of the wake up code, it is possible |
| 13023 | // that the network link comes UP after 60 seconds and we never set the OWNER option |
| 13024 | m->AnnounceOwner = NonZeroTime(m->timenow + 60 * mDNSPlatformOneSecond); |
| 13025 | LogInfo("mDNS_RegisterInterface: Setting AnnounceOwner" ); |
| 13026 | |
| 13027 | m->mDNSStats.InterfaceUp++; |
| 13028 | for (q = m->Questions; q; q=q->next) // Scan our list of questions |
| 13029 | { |
| 13030 | if (mDNSOpaque16IsZero(q->TargetQID)) |
| 13031 | { |
| 13032 | if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) // If non-specific Q, or Q on this specific interface, |
| 13033 | { // then reactivate this question |
| 13034 | // If flapping, delay between first and second queries is nine seconds instead of one second |
| 13035 | mDNSBool dodelay = (activationSpeed == SlowActivation) && (q->FlappingInterface1 == set->InterfaceID || q->FlappingInterface2 == set->InterfaceID); |
| 13036 | mDNSs32 initial = dodelay ? InitialQuestionInterval * QuestionIntervalStep2 : InitialQuestionInterval; |
| 13037 | mDNSs32 qdelay = dodelay ? kDefaultQueryDelayTimeForFlappingInterface : 0; |
| 13038 | if (dodelay) LogInfo("No cache records expired for %##s (%s); delaying questions by %d seconds" , q->qname.c, DNSTypeName(q->qtype), qdelay); |
| 13039 | |
| 13040 | if (!q->ThisQInterval || q->ThisQInterval > initial) |
| 13041 | { |
| 13042 | q->ThisQInterval = initial; |
| 13043 | q->RequestUnicast = kDefaultRequestUnicastCount; |
| 13044 | } |
| 13045 | q->LastQTime = m->timenow - q->ThisQInterval + qdelay; |
| 13046 | q->RecentAnswerPkts = 0; |
| 13047 | // Change the salt |
| 13048 | ReInitAnonInfo(&q->AnonInfo, &q->qname); |
| 13049 | SetNextQueryTime(m,q); |
| 13050 | } |
| 13051 | } |
| 13052 | } |
| 13053 | |
| 13054 | // For all our non-specific authoritative resource records (and any dormant records specific to this interface) |
| 13055 | // we now need them to re-probe if necessary, and then re-announce. |
| 13056 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 13057 | { |
| 13058 | if (!rr->resrec.InterfaceID || rr->resrec.InterfaceID == set->InterfaceID) |
| 13059 | { |
| 13060 | // Change the salt |
| 13061 | ReInitAnonInfo(&rr->resrec.AnonInfo, rr->resrec.name); |
| 13062 | mDNSCoreRestartRegistration(m, rr, numannounce); |
| 13063 | } |
| 13064 | } |
| 13065 | #if APPLE_OSX_mDNSResponder && !TARGET_OS_IPHONE |
| 13066 | DNSSECProbe(m); |
| 13067 | #endif |
| 13068 | } |
| 13069 | |
| 13070 | RestartRecordGetZoneData(m); |
| 13071 | |
| 13072 | mDNS_UpdateAllowSleep(m); |
| 13073 | |
| 13074 | mDNS_Unlock(m); |
| 13075 | return(mStatus_NoError); |
| 13076 | } |
| 13077 | |
| 13078 | // Note: mDNS_DeregisterInterface calls mDNS_Deregister_internal which can call a user callback, which may change |
| 13079 | // the record list and/or question list. |
| 13080 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 13081 | mDNSexport void mDNS_DeregisterInterface(mDNS *const m, NetworkInterfaceInfo *set, InterfaceActivationSpeed activationSpeed) |
| 13082 | { |
| 13083 | NetworkInterfaceInfo **p = &m->HostInterfaces; |
| 13084 | mDNSBool revalidate = mDNSfalse; |
| 13085 | NetworkInterfaceInfo *primary; |
| 13086 | NetworkInterfaceInfo *intf; |
| 13087 | AuthRecord *A; |
| 13088 | |
| 13089 | mDNS_Lock(m); |
| 13090 | |
| 13091 | // Find this record in our list |
| 13092 | while (*p && *p != set) p=&(*p)->next; |
| 13093 | if (!*p) { debugf("mDNS_DeregisterInterface: NetworkInterfaceInfo not found in list" ); mDNS_Unlock(m); return; } |
| 13094 | |
| 13095 | mDNS_DeactivateNetWake_internal(m, set); |
| 13096 | |
| 13097 | // Unlink this record from our list |
| 13098 | *p = (*p)->next; |
| 13099 | set->next = mDNSNULL; |
| 13100 | |
| 13101 | if (!set->InterfaceActive) |
| 13102 | { |
| 13103 | // If this interface not the active member of its set, update the v4/v6Available flags for the active member |
| 13104 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 13105 | if (intf->InterfaceActive && intf->InterfaceID == set->InterfaceID) |
| 13106 | UpdateInterfaceProtocols(m, intf); |
| 13107 | } |
| 13108 | else |
| 13109 | { |
| 13110 | intf = FirstInterfaceForID(m, set->InterfaceID); |
| 13111 | if (intf) |
| 13112 | { |
| 13113 | LogInfo("mDNS_DeregisterInterface: Another representative of InterfaceID %d %s (%#a) exists;" |
| 13114 | " making it active" , IID(set->InterfaceID), set->ifname, &set->ip); |
| 13115 | if (intf->InterfaceActive) |
| 13116 | LogMsg("mDNS_DeregisterInterface: ERROR intf->InterfaceActive already set for %s (%#a)" , set->ifname, &set->ip); |
| 13117 | intf->InterfaceActive = mDNStrue; |
| 13118 | UpdateInterfaceProtocols(m, intf); |
| 13119 | |
| 13120 | if (intf->NetWake) mDNS_ActivateNetWake_internal(m, intf); |
| 13121 | |
| 13122 | // See if another representative *of the same type* exists. If not, we mave have gone from |
| 13123 | // dual-stack to v6-only (or v4-only) so we need to reconfirm which records are still valid. |
| 13124 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 13125 | if (intf->InterfaceID == set->InterfaceID && intf->ip.type == set->ip.type) |
| 13126 | break; |
| 13127 | if (!intf) revalidate = mDNStrue; |
| 13128 | } |
| 13129 | else |
| 13130 | { |
| 13131 | mDNSu32 slot; |
| 13132 | CacheGroup *cg; |
| 13133 | CacheRecord *rr; |
| 13134 | DNSQuestion *q; |
| 13135 | |
| 13136 | LogInfo("mDNS_DeregisterInterface: Last representative of InterfaceID %d %s (%#a) deregistered;" |
| 13137 | " marking questions etc. dormant" , IID(set->InterfaceID), set->ifname, &set->ip); |
| 13138 | |
| 13139 | m->mDNSStats.InterfaceDown++; |
| 13140 | |
| 13141 | if (set->McastTxRx && (activationSpeed == SlowActivation)) |
| 13142 | { |
| 13143 | LogMsg("mDNS_DeregisterInterface: Frequent transitions for interface %s (%#a)" , set->ifname, &set->ip); |
| 13144 | m->mDNSStats.InterfaceDownFlap++; |
| 13145 | } |
| 13146 | |
| 13147 | // 1. Deactivate any questions specific to this interface, and tag appropriate questions |
| 13148 | // so that mDNS_RegisterInterface() knows how swiftly it needs to reactivate them |
| 13149 | for (q = m->Questions; q; q=q->next) |
| 13150 | { |
| 13151 | if (q->InterfaceID == set->InterfaceID) q->ThisQInterval = 0; |
| 13152 | if (!q->InterfaceID || q->InterfaceID == set->InterfaceID) |
| 13153 | { |
| 13154 | q->FlappingInterface2 = q->FlappingInterface1; |
| 13155 | q->FlappingInterface1 = set->InterfaceID; // Keep history of the last two interfaces to go away |
| 13156 | } |
| 13157 | } |
| 13158 | |
| 13159 | // 2. Flush any cache records received on this interface |
| 13160 | revalidate = mDNSfalse; // Don't revalidate if we're flushing the records |
| 13161 | FORALL_CACHERECORDS(slot, cg, rr) |
| 13162 | { |
| 13163 | if (rr->resrec.InterfaceID == set->InterfaceID) |
| 13164 | { |
| 13165 | // If this interface is deemed flapping, |
| 13166 | // postpone deleting the cache records in case the interface comes back again |
| 13167 | if (set->McastTxRx && (activationSpeed == SlowActivation)) |
| 13168 | { |
| 13169 | // For a flapping interface we want these records to go away after |
| 13170 | // kDefaultReconfirmTimeForFlappingInterface seconds if they are not reconfirmed. |
| 13171 | mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface); |
| 13172 | // We set UnansweredQueries = MaxUnansweredQueries so we don't waste time doing any queries for them -- |
| 13173 | // if the interface does come back, any relevant questions will be reactivated anyway |
| 13174 | rr->UnansweredQueries = MaxUnansweredQueries; |
| 13175 | } |
| 13176 | else |
| 13177 | { |
| 13178 | mDNS_PurgeCacheResourceRecord(m, rr); |
| 13179 | } |
| 13180 | } |
| 13181 | } |
| 13182 | } |
| 13183 | } |
| 13184 | |
| 13185 | // If we still have address records referring to this one, update them. |
| 13186 | // This is safe, because this NetworkInterfaceInfo has already been unlinked from the list, |
| 13187 | // so the call to FindFirstAdvertisedInterface() won’t accidentally find it. |
| 13188 | primary = FindFirstAdvertisedInterface(m); |
| 13189 | A = primary ? &primary->RR_A : mDNSNULL; |
| 13190 | for (intf = m->HostInterfaces; intf; intf = intf->next) |
| 13191 | if (intf->RR_A.RRSet == &set->RR_A) |
| 13192 | intf->RR_A.RRSet = A; |
| 13193 | |
| 13194 | // If we were advertising on this interface, deregister those address and reverse-lookup records now |
| 13195 | if (set->Advertise) DeadvertiseInterface(m, set); |
| 13196 | |
| 13197 | // If we have any cache records received on this interface that went away, then re-verify them. |
| 13198 | // In some versions of OS X the IPv6 address remains on an interface even when the interface is turned off, |
| 13199 | // giving the false impression that there's an active representative of this interface when there really isn't. |
| 13200 | // Don't need to do this when shutting down, because *all* interfaces are about to go away |
| 13201 | if (revalidate && !m->ShutdownTime) |
| 13202 | { |
| 13203 | mDNSu32 slot; |
| 13204 | CacheGroup *cg; |
| 13205 | CacheRecord *rr; |
| 13206 | FORALL_CACHERECORDS(slot, cg, rr) |
| 13207 | if (rr->resrec.InterfaceID == set->InterfaceID) |
| 13208 | mDNS_Reconfirm_internal(m, rr, kDefaultReconfirmTimeForFlappingInterface); |
| 13209 | } |
| 13210 | |
| 13211 | mDNS_UpdateAllowSleep(m); |
| 13212 | |
| 13213 | mDNS_Unlock(m); |
| 13214 | } |
| 13215 | |
| 13216 | mDNSlocal void SetAnonInfoSRS(ServiceRecordSet *sr, int NumSubTypes) |
| 13217 | { |
| 13218 | int i, len; |
| 13219 | |
| 13220 | if (!sr->AnonData) |
| 13221 | return; |
| 13222 | |
| 13223 | len = mDNSPlatformStrLen(sr->AnonData); |
| 13224 | if (sr->RR_PTR.resrec.AnonInfo) |
| 13225 | { |
| 13226 | LogMsg("SetAnonInfoSRS: Freeing AnonInfo for PTR record %##s, should have been freed already" , sr->RR_PTR.resrec.name->c); |
| 13227 | FreeAnonInfo(sr->RR_PTR.resrec.AnonInfo); |
| 13228 | } |
| 13229 | sr->RR_PTR.resrec.AnonInfo = AllocateAnonInfo(sr->RR_PTR.resrec.name, sr->AnonData, len, mDNSNULL); |
| 13230 | for (i=0; i<NumSubTypes; i++) |
| 13231 | { |
| 13232 | if (sr->SubTypes[i].resrec.AnonInfo) |
| 13233 | { |
| 13234 | LogMsg("SetAnonInfoSRS: Freeing AnonInfo for subtype record %##s, should have been freed already" , sr->SubTypes[i].resrec.name->c); |
| 13235 | FreeAnonInfo(sr->SubTypes[i].resrec.AnonInfo); |
| 13236 | } |
| 13237 | sr->SubTypes[i].resrec.AnonInfo = AllocateAnonInfo(sr->SubTypes[i].resrec.name, sr->AnonData, len, mDNSNULL); |
| 13238 | } |
| 13239 | } |
| 13240 | |
| 13241 | mDNSlocal void ResetAnonInfoSRS(ServiceRecordSet *sr, int NumSubTypes) |
| 13242 | { |
| 13243 | int i; |
| 13244 | |
| 13245 | if (!sr->AnonData) |
| 13246 | return; |
| 13247 | if (sr->RR_PTR.resrec.AnonInfo) |
| 13248 | { |
| 13249 | FreeAnonInfo(sr->RR_PTR.resrec.AnonInfo); |
| 13250 | sr->RR_PTR.resrec.AnonInfo = mDNSNULL; |
| 13251 | } |
| 13252 | for (i=0; i<NumSubTypes; i++) |
| 13253 | { |
| 13254 | if (sr->SubTypes[i].resrec.AnonInfo) |
| 13255 | { |
| 13256 | FreeAnonInfo(sr->SubTypes[i].resrec.AnonInfo); |
| 13257 | sr->SubTypes[i].resrec.AnonInfo = mDNSNULL; |
| 13258 | } |
| 13259 | } |
| 13260 | } |
| 13261 | |
| 13262 | mDNSlocal void ServiceCallback(mDNS *const m, AuthRecord *const rr, mStatus result) |
| 13263 | { |
| 13264 | ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext; |
| 13265 | (void)m; // Unused parameter |
| 13266 | |
| 13267 | #if MDNS_DEBUGMSGS |
| 13268 | { |
| 13269 | char *msg = "Unknown result" ; |
| 13270 | if (result == mStatus_NoError) msg = "Name Registered" ; |
| 13271 | else if (result == mStatus_NameConflict) msg = "Name Conflict" ; |
| 13272 | else if (result == mStatus_MemFree) msg = "Memory Free" ; |
| 13273 | debugf("ServiceCallback: %##s (%s) %s (%d)" , rr->resrec.name->c, DNSTypeName(rr->resrec.rrtype), msg, result); |
| 13274 | } |
| 13275 | #endif |
| 13276 | |
| 13277 | // Only pass on the NoError acknowledgement for the SRV record (when it finishes probing) |
| 13278 | if (result == mStatus_NoError && rr != &sr->RR_SRV) return; |
| 13279 | |
| 13280 | // If we got a name conflict on either SRV or TXT, forcibly deregister this service, and record that we did that |
| 13281 | if (result == mStatus_NameConflict) |
| 13282 | { |
| 13283 | sr->Conflict = mDNStrue; // Record that this service set had a conflict |
| 13284 | mDNS_DeregisterService(m, sr); // Unlink the records from our list |
| 13285 | return; |
| 13286 | } |
| 13287 | |
| 13288 | if (result == mStatus_MemFree) |
| 13289 | { |
| 13290 | // If the SRV/TXT/PTR records, or the _services._dns-sd._udp record, or any of the subtype PTR records, |
| 13291 | // are still in the process of deregistering, don't pass on the NameConflict/MemFree message until |
| 13292 | // every record is finished cleaning up. |
| 13293 | mDNSu32 i; |
| 13294 | ExtraResourceRecord *e = sr->Extras; |
| 13295 | |
| 13296 | if (sr->RR_SRV.resrec.RecordType != kDNSRecordTypeUnregistered) return; |
| 13297 | if (sr->RR_TXT.resrec.RecordType != kDNSRecordTypeUnregistered) return; |
| 13298 | if (sr->RR_PTR.resrec.RecordType != kDNSRecordTypeUnregistered) return; |
| 13299 | if (sr->RR_ADV.resrec.RecordType != kDNSRecordTypeUnregistered) return; |
| 13300 | for (i=0; i<sr->NumSubTypes; i++) if (sr->SubTypes[i].resrec.RecordType != kDNSRecordTypeUnregistered) return; |
| 13301 | |
| 13302 | while (e) |
| 13303 | { |
| 13304 | if (e->r.resrec.RecordType != kDNSRecordTypeUnregistered) return; |
| 13305 | e = e->next; |
| 13306 | } |
| 13307 | ResetAnonInfoSRS(sr, sr->NumSubTypes); |
| 13308 | |
| 13309 | // If this ServiceRecordSet was forcibly deregistered, and now its memory is ready for reuse, |
| 13310 | // then we can now report the NameConflict to the client |
| 13311 | if (sr->Conflict) result = mStatus_NameConflict; |
| 13312 | |
| 13313 | } |
| 13314 | |
| 13315 | LogInfo("ServiceCallback: All records %s for %##s" , (result == mStatus_MemFree ? "Unregistered" : "Registered" ), sr->RR_PTR.resrec.name->c); |
| 13316 | // CAUTION: MUST NOT do anything more with sr after calling sr->Callback(), because the client's callback |
| 13317 | // function is allowed to do anything, including deregistering this service and freeing its memory. |
| 13318 | if (sr->ServiceCallback) |
| 13319 | sr->ServiceCallback(m, sr, result); |
| 13320 | } |
| 13321 | |
| 13322 | mDNSlocal void NSSCallback(mDNS *const m, AuthRecord *const rr, mStatus result) |
| 13323 | { |
| 13324 | ServiceRecordSet *sr = (ServiceRecordSet *)rr->RecordContext; |
| 13325 | if (sr->ServiceCallback) |
| 13326 | sr->ServiceCallback(m, sr, result); |
| 13327 | } |
| 13328 | |
| 13329 | |
| 13330 | // Derive AuthRecType from the kDNSServiceFlags* values. |
| 13331 | mDNSlocal AuthRecType setAuthRecType(mDNSInterfaceID InterfaceID, mDNSu32 flags) |
| 13332 | { |
| 13333 | AuthRecType artype; |
| 13334 | |
| 13335 | if (InterfaceID == mDNSInterface_LocalOnly) |
| 13336 | artype = AuthRecordLocalOnly; |
| 13337 | else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE) |
| 13338 | artype = AuthRecordP2P; |
| 13339 | else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P) |
| 13340 | && (flags & kDNSServiceFlagsIncludeAWDL)) |
| 13341 | artype = AuthRecordAnyIncludeAWDLandP2P; |
| 13342 | else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeP2P)) |
| 13343 | artype = AuthRecordAnyIncludeP2P; |
| 13344 | else if ((InterfaceID == mDNSInterface_Any) && (flags & kDNSServiceFlagsIncludeAWDL)) |
| 13345 | artype = AuthRecordAnyIncludeAWDL; |
| 13346 | else |
| 13347 | artype = AuthRecordAny; |
| 13348 | |
| 13349 | return artype; |
| 13350 | } |
| 13351 | |
| 13352 | // Used to derive the original D2D specific flags specified by the client in the registration |
| 13353 | // when we don't have access to the original flag (kDNSServiceFlags*) values. |
| 13354 | mDNSexport mDNSu32 deriveD2DFlagsFromAuthRecType(AuthRecType authRecType) |
| 13355 | { |
| 13356 | mDNSu32 flags = 0; |
| 13357 | if ((authRecType == AuthRecordAnyIncludeP2P) || (authRecType == AuthRecordAnyIncludeAWDLandP2P)) |
| 13358 | flags |= kDNSServiceFlagsIncludeP2P; |
| 13359 | else if ((authRecType == AuthRecordAnyIncludeAWDL) || (authRecType == AuthRecordAnyIncludeAWDLandP2P)) |
| 13360 | flags |= kDNSServiceFlagsIncludeAWDL; |
| 13361 | return flags; |
| 13362 | } |
| 13363 | |
| 13364 | // Note: |
| 13365 | // Name is first label of domain name (any dots in the name are actual dots, not label separators) |
| 13366 | // Type is service type (e.g. "_ipp._tcp.") |
| 13367 | // Domain is fully qualified domain name (i.e. ending with a null label) |
| 13368 | // We always register a TXT, even if it is empty (so that clients are not |
| 13369 | // left waiting forever looking for a nonexistent record.) |
| 13370 | // If the host parameter is mDNSNULL or the root domain (ASCII NUL), |
| 13371 | // then the default host name (m->MulticastHostname) is automatically used |
| 13372 | // If the optional target host parameter is set, then the storage it points to must remain valid for the lifetime of the service registration |
| 13373 | mDNSexport mStatus mDNS_RegisterService(mDNS *const m, ServiceRecordSet *sr, |
| 13374 | const domainlabel *const name, const domainname *const type, const domainname *const domain, |
| 13375 | const domainname *const host, mDNSIPPort port, const mDNSu8 txtinfo[], mDNSu16 txtlen, |
| 13376 | AuthRecord *SubTypes, mDNSu32 NumSubTypes, |
| 13377 | mDNSInterfaceID InterfaceID, mDNSServiceCallback Callback, void *Context, mDNSu32 flags) |
| 13378 | { |
| 13379 | mStatus err; |
| 13380 | mDNSu32 i; |
| 13381 | mDNSu32 hostTTL; |
| 13382 | AuthRecType artype; |
| 13383 | mDNSu8 recordType = (flags & kDNSServiceFlagsKnownUnique) ? kDNSRecordTypeKnownUnique : kDNSRecordTypeUnique; |
| 13384 | |
| 13385 | sr->ServiceCallback = Callback; |
| 13386 | sr->ServiceContext = Context; |
| 13387 | sr->Conflict = mDNSfalse; |
| 13388 | |
| 13389 | sr->Extras = mDNSNULL; |
| 13390 | sr->NumSubTypes = NumSubTypes; |
| 13391 | sr->SubTypes = SubTypes; |
| 13392 | sr->flags = flags; |
| 13393 | |
| 13394 | artype = setAuthRecType(InterfaceID, flags); |
| 13395 | |
| 13396 | // Initialize the AuthRecord objects to sane values |
| 13397 | // Need to initialize everything correctly *before* making the decision whether to do a RegisterNoSuchService and bail out |
| 13398 | mDNS_SetupResourceRecord(&sr->RR_ADV, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeAdvisory, artype, ServiceCallback, sr); |
| 13399 | mDNS_SetupResourceRecord(&sr->RR_PTR, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr); |
| 13400 | |
| 13401 | if (flags & kDNSServiceFlagsWakeOnlyService) |
| 13402 | { |
| 13403 | sr->RR_PTR.AuthFlags = AuthFlagsWakeOnly; |
| 13404 | } |
| 13405 | |
| 13406 | if (SameDomainName(type, (const domainname *) "\x4" "_ubd" "\x4" "_tcp" )) |
| 13407 | hostTTL = kHostNameSmallTTL; |
| 13408 | else |
| 13409 | hostTTL = kHostNameTTL; |
| 13410 | |
| 13411 | mDNS_SetupResourceRecord(&sr->RR_SRV, mDNSNULL, InterfaceID, kDNSType_SRV, hostTTL, recordType, artype, ServiceCallback, sr); |
| 13412 | mDNS_SetupResourceRecord(&sr->RR_TXT, mDNSNULL, InterfaceID, kDNSType_TXT, kStandardTTL, recordType, artype, ServiceCallback, sr); |
| 13413 | |
| 13414 | // If port number is zero, that means the client is really trying to do a RegisterNoSuchService |
| 13415 | if (mDNSIPPortIsZero(port)) |
| 13416 | return(mDNS_RegisterNoSuchService(m, &sr->RR_SRV, name, type, domain, mDNSNULL, InterfaceID, NSSCallback, sr, flags)); |
| 13417 | |
| 13418 | // If the caller is registering an oversized TXT record, |
| 13419 | // it is the caller's responsibility to allocate a ServiceRecordSet structure that is large enough for it |
| 13420 | if (sr->RR_TXT.resrec.rdata->MaxRDLength < txtlen) |
| 13421 | sr->RR_TXT.resrec.rdata->MaxRDLength = txtlen; |
| 13422 | |
| 13423 | // Set up the record names |
| 13424 | // For now we only create an advisory record for the main type, not for subtypes |
| 13425 | // We need to gain some operational experience before we decide if there's a need to create them for subtypes too |
| 13426 | if (ConstructServiceName(&sr->RR_ADV.namestorage, (const domainlabel*)"\x09_services" , (const domainname*)"\x07_dns-sd\x04_udp" , domain) == mDNSNULL) |
| 13427 | return(mStatus_BadParamErr); |
| 13428 | if (ConstructServiceName(&sr->RR_PTR.namestorage, mDNSNULL, type, domain) == mDNSNULL) return(mStatus_BadParamErr); |
| 13429 | if (ConstructServiceName(&sr->RR_SRV.namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr); |
| 13430 | AssignDomainName(&sr->RR_TXT.namestorage, sr->RR_SRV.resrec.name); |
| 13431 | |
| 13432 | // 1. Set up the ADV record rdata to advertise our service type |
| 13433 | AssignDomainName(&sr->RR_ADV.resrec.rdata->u.name, sr->RR_PTR.resrec.name); |
| 13434 | |
| 13435 | // 2. Set up the PTR record rdata to point to our service name |
| 13436 | // We set up two additionals, so when a client asks for this PTR we automatically send the SRV and the TXT too |
| 13437 | // Note: uDNS registration code assumes that Additional1 points to the SRV record |
| 13438 | AssignDomainName(&sr->RR_PTR.resrec.rdata->u.name, sr->RR_SRV.resrec.name); |
| 13439 | sr->RR_PTR.Additional1 = &sr->RR_SRV; |
| 13440 | sr->RR_PTR.Additional2 = &sr->RR_TXT; |
| 13441 | |
| 13442 | // 2a. Set up any subtype PTRs to point to our service name |
| 13443 | // If the client is using subtypes, it is the client's responsibility to have |
| 13444 | // already set the first label of the record name to the subtype being registered |
| 13445 | for (i=0; i<NumSubTypes; i++) |
| 13446 | { |
| 13447 | domainname st; |
| 13448 | AssignDomainName(&st, sr->SubTypes[i].resrec.name); |
| 13449 | st.c[1+st.c[0]] = 0; // Only want the first label, not the whole FQDN (particularly for mDNS_RenameAndReregisterService()) |
| 13450 | AppendDomainName(&st, type); |
| 13451 | mDNS_SetupResourceRecord(&sr->SubTypes[i], mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, ServiceCallback, sr); |
| 13452 | if (ConstructServiceName(&sr->SubTypes[i].namestorage, mDNSNULL, &st, domain) == mDNSNULL) return(mStatus_BadParamErr); |
| 13453 | AssignDomainName(&sr->SubTypes[i].resrec.rdata->u.name, &sr->RR_SRV.namestorage); |
| 13454 | sr->SubTypes[i].Additional1 = &sr->RR_SRV; |
| 13455 | sr->SubTypes[i].Additional2 = &sr->RR_TXT; |
| 13456 | } |
| 13457 | |
| 13458 | SetAnonInfoSRS(sr, NumSubTypes); |
| 13459 | |
| 13460 | // 3. Set up the SRV record rdata. |
| 13461 | sr->RR_SRV.resrec.rdata->u.srv.priority = 0; |
| 13462 | sr->RR_SRV.resrec.rdata->u.srv.weight = 0; |
| 13463 | sr->RR_SRV.resrec.rdata->u.srv.port = port; |
| 13464 | |
| 13465 | // Setting AutoTarget tells DNS that the target of this SRV is to be automatically kept in sync with our host name |
| 13466 | if (host && host->c[0]) AssignDomainName(&sr->RR_SRV.resrec.rdata->u.srv.target, host); |
| 13467 | else { sr->RR_SRV.AutoTarget = Target_AutoHost; sr->RR_SRV.resrec.rdata->u.srv.target.c[0] = '\0'; } |
| 13468 | |
| 13469 | // 4. Set up the TXT record rdata, |
| 13470 | // and set DependentOn because we're depending on the SRV record to find and resolve conflicts for us |
| 13471 | // Note: uDNS registration code assumes that DependentOn points to the SRV record |
| 13472 | if (txtinfo == mDNSNULL) sr->RR_TXT.resrec.rdlength = 0; |
| 13473 | else if (txtinfo != sr->RR_TXT.resrec.rdata->u.txt.c) |
| 13474 | { |
| 13475 | sr->RR_TXT.resrec.rdlength = txtlen; |
| 13476 | if (sr->RR_TXT.resrec.rdlength > sr->RR_TXT.resrec.rdata->MaxRDLength) return(mStatus_BadParamErr); |
| 13477 | mDNSPlatformMemCopy(sr->RR_TXT.resrec.rdata->u.txt.c, txtinfo, txtlen); |
| 13478 | } |
| 13479 | sr->RR_TXT.DependentOn = &sr->RR_SRV; |
| 13480 | |
| 13481 | mDNS_Lock(m); |
| 13482 | // It is important that we register SRV first. uDNS assumes that SRV is registered first so |
| 13483 | // that if the SRV cannot find a target, rest of the records that belong to this service |
| 13484 | // will not be activated. |
| 13485 | err = mDNS_Register_internal(m, &sr->RR_SRV); |
| 13486 | // If we can't register the SRV record due to errors, bail out. It has not been inserted in |
| 13487 | // any list and hence no need to deregister. We could probably do similar checks for other |
| 13488 | // records below and bail out. For now, this seems to be sufficient to address rdar://9304275 |
| 13489 | if (err) |
| 13490 | { |
| 13491 | mDNS_Unlock(m); |
| 13492 | return err; |
| 13493 | } |
| 13494 | if (!err) err = mDNS_Register_internal(m, &sr->RR_TXT); |
| 13495 | // We register the RR_PTR last, because we want to be sure that in the event of a forced call to |
| 13496 | // mDNS_StartExit, the RR_PTR will be the last one to be forcibly deregistered, since that is what triggers |
| 13497 | // the mStatus_MemFree callback to ServiceCallback, which in turn passes on the mStatus_MemFree back to |
| 13498 | // the client callback, which is then at liberty to free the ServiceRecordSet memory at will. We need to |
| 13499 | // make sure we've deregistered all our records and done any other necessary cleanup before that happens. |
| 13500 | if (!err) err = mDNS_Register_internal(m, &sr->RR_ADV); |
| 13501 | for (i=0; i<NumSubTypes; i++) if (!err) err = mDNS_Register_internal(m, &sr->SubTypes[i]); |
| 13502 | if (!err) err = mDNS_Register_internal(m, &sr->RR_PTR); |
| 13503 | |
| 13504 | mDNS_Unlock(m); |
| 13505 | |
| 13506 | if (err) mDNS_DeregisterService(m, sr); |
| 13507 | return(err); |
| 13508 | } |
| 13509 | |
| 13510 | mDNSexport mStatus mDNS_AddRecordToService(mDNS *const m, ServiceRecordSet *sr, |
| 13511 | ExtraResourceRecord *, RData *rdata, mDNSu32 ttl, mDNSu32 flags) |
| 13512 | { |
| 13513 | ExtraResourceRecord **e; |
| 13514 | mStatus status; |
| 13515 | AuthRecType artype; |
| 13516 | mDNSInterfaceID InterfaceID = sr->RR_PTR.resrec.InterfaceID; |
| 13517 | ResourceRecord *rr; |
| 13518 | |
| 13519 | artype = setAuthRecType(InterfaceID, flags); |
| 13520 | |
| 13521 | extra->next = mDNSNULL; |
| 13522 | mDNS_SetupResourceRecord(&extra->r, rdata, sr->RR_PTR.resrec.InterfaceID, |
| 13523 | extra->r.resrec.rrtype, ttl, kDNSRecordTypeUnique, artype, ServiceCallback, sr); |
| 13524 | AssignDomainName(&extra->r.namestorage, sr->RR_SRV.resrec.name); |
| 13525 | |
| 13526 | mDNS_Lock(m); |
| 13527 | rr = mDNSNULL; |
| 13528 | if (extra->r.resrec.rrtype == kDNSType_TXT) |
| 13529 | { |
| 13530 | if (sr->RR_TXT.resrec.RecordType & kDNSRecordTypeUniqueMask) rr = &sr->RR_TXT.resrec; |
| 13531 | } |
| 13532 | else if (extra->r.resrec.rrtype == kDNSType_SRV) |
| 13533 | { |
| 13534 | if (sr->RR_SRV.resrec.RecordType & kDNSRecordTypeUniqueMask) rr = &sr->RR_SRV.resrec; |
| 13535 | } |
| 13536 | |
| 13537 | if (!rr) |
| 13538 | { |
| 13539 | ExtraResourceRecord *; |
| 13540 | |
| 13541 | for (srExtra = sr->Extras; srExtra; srExtra = srExtra->next) |
| 13542 | { |
| 13543 | if ((srExtra->r.resrec.rrtype == extra->r.resrec.rrtype) && (srExtra->r.resrec.RecordType & kDNSRecordTypeUniqueMask)) |
| 13544 | { |
| 13545 | rr = &srExtra->r.resrec; |
| 13546 | break; |
| 13547 | } |
| 13548 | } |
| 13549 | } |
| 13550 | |
| 13551 | if (rr && (extra->r.resrec.rroriginalttl != rr->rroriginalttl)) |
| 13552 | { |
| 13553 | LogMsg("mDNS_AddRecordToService: Correcting TTL from %4d to %4d for %s" , |
| 13554 | extra->r.resrec.rroriginalttl, rr->rroriginalttl, RRDisplayString(m, &extra->r.resrec)); |
| 13555 | extra->r.resrec.rroriginalttl = rr->rroriginalttl; |
| 13556 | } |
| 13557 | |
| 13558 | e = &sr->Extras; |
| 13559 | while (*e) e = &(*e)->next; |
| 13560 | |
| 13561 | extra->r.DependentOn = &sr->RR_SRV; |
| 13562 | |
| 13563 | debugf("mDNS_AddRecordToService adding record to %##s %s %d" , |
| 13564 | extra->r.resrec.name->c, DNSTypeName(extra->r.resrec.rrtype), extra->r.resrec.rdlength); |
| 13565 | |
| 13566 | status = mDNS_Register_internal(m, &extra->r); |
| 13567 | if (status == mStatus_NoError) *e = extra; |
| 13568 | |
| 13569 | mDNS_Unlock(m); |
| 13570 | return(status); |
| 13571 | } |
| 13572 | |
| 13573 | mDNSexport mStatus mDNS_RemoveRecordFromService(mDNS *const m, ServiceRecordSet *sr, ExtraResourceRecord *, |
| 13574 | mDNSRecordCallback MemFreeCallback, void *Context) |
| 13575 | { |
| 13576 | ExtraResourceRecord **e; |
| 13577 | mStatus status; |
| 13578 | |
| 13579 | mDNS_Lock(m); |
| 13580 | e = &sr->Extras; |
| 13581 | while (*e && *e != extra) e = &(*e)->next; |
| 13582 | if (!*e) |
| 13583 | { |
| 13584 | debugf("mDNS_RemoveRecordFromService failed to remove record from %##s" , extra->r.resrec.name->c); |
| 13585 | status = mStatus_BadReferenceErr; |
| 13586 | } |
| 13587 | else |
| 13588 | { |
| 13589 | debugf("mDNS_RemoveRecordFromService removing record from %##s" , extra->r.resrec.name->c); |
| 13590 | extra->r.RecordCallback = MemFreeCallback; |
| 13591 | extra->r.RecordContext = Context; |
| 13592 | *e = (*e)->next; |
| 13593 | status = mDNS_Deregister_internal(m, &extra->r, mDNS_Dereg_normal); |
| 13594 | } |
| 13595 | mDNS_Unlock(m); |
| 13596 | return(status); |
| 13597 | } |
| 13598 | |
| 13599 | mDNSexport mStatus mDNS_RenameAndReregisterService(mDNS *const m, ServiceRecordSet *const sr, const domainlabel *newname) |
| 13600 | { |
| 13601 | // Note: Don't need to use mDNS_Lock(m) here, because this code is just using public routines |
| 13602 | // mDNS_RegisterService() and mDNS_AddRecordToService(), which do the right locking internally. |
| 13603 | domainlabel name1, name2; |
| 13604 | domainname type, domain; |
| 13605 | const domainname *host = sr->RR_SRV.AutoTarget ? mDNSNULL : &sr->RR_SRV.resrec.rdata->u.srv.target; |
| 13606 | ExtraResourceRecord * = sr->Extras; |
| 13607 | mStatus err; |
| 13608 | |
| 13609 | DeconstructServiceName(sr->RR_SRV.resrec.name, &name1, &type, &domain); |
| 13610 | if (!newname) |
| 13611 | { |
| 13612 | name2 = name1; |
| 13613 | IncrementLabelSuffix(&name2, mDNStrue); |
| 13614 | newname = &name2; |
| 13615 | } |
| 13616 | |
| 13617 | if (SameDomainName(&domain, &localdomain)) |
| 13618 | debugf("%##s service renamed from \"%#s\" to \"%#s\"" , type.c, name1.c, newname->c); |
| 13619 | else debugf("%##s service (domain %##s) renamed from \"%#s\" to \"%#s\"" ,type.c, domain.c, name1.c, newname->c); |
| 13620 | |
| 13621 | err = mDNS_RegisterService(m, sr, newname, &type, &domain, |
| 13622 | host, sr->RR_SRV.resrec.rdata->u.srv.port, sr->RR_TXT.resrec.rdata->u.txt.c, sr->RR_TXT.resrec.rdlength, |
| 13623 | sr->SubTypes, sr->NumSubTypes, |
| 13624 | sr->RR_PTR.resrec.InterfaceID, sr->ServiceCallback, sr->ServiceContext, sr->flags); |
| 13625 | |
| 13626 | // mDNS_RegisterService() just reset sr->Extras to NULL. |
| 13627 | // Fortunately we already grabbed ourselves a copy of this pointer (above), so we can now run |
| 13628 | // through the old list of extra records, and re-add them to our freshly created service registration |
| 13629 | while (!err && extras) |
| 13630 | { |
| 13631 | ExtraResourceRecord *e = extras; |
| 13632 | extras = extras->next; |
| 13633 | err = mDNS_AddRecordToService(m, sr, e, e->r.resrec.rdata, e->r.resrec.rroriginalttl, 0); |
| 13634 | } |
| 13635 | |
| 13636 | return(err); |
| 13637 | } |
| 13638 | |
| 13639 | // Note: mDNS_DeregisterService calls mDNS_Deregister_internal which can call a user callback, |
| 13640 | // which may change the record list and/or question list. |
| 13641 | // Any code walking either list must use the CurrentQuestion and/or CurrentRecord mechanism to protect against this. |
| 13642 | mDNSexport mStatus mDNS_DeregisterService_drt(mDNS *const m, ServiceRecordSet *sr, mDNS_Dereg_type drt) |
| 13643 | { |
| 13644 | // If port number is zero, that means this was actually registered using mDNS_RegisterNoSuchService() |
| 13645 | if (mDNSIPPortIsZero(sr->RR_SRV.resrec.rdata->u.srv.port)) return(mDNS_DeregisterNoSuchService(m, &sr->RR_SRV)); |
| 13646 | |
| 13647 | if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeUnregistered) |
| 13648 | { |
| 13649 | debugf("Service set for %##s already deregistered" , sr->RR_SRV.resrec.name->c); |
| 13650 | return(mStatus_BadReferenceErr); |
| 13651 | } |
| 13652 | else if (sr->RR_PTR.resrec.RecordType == kDNSRecordTypeDeregistering) |
| 13653 | { |
| 13654 | LogInfo("Service set for %##s already in the process of deregistering" , sr->RR_SRV.resrec.name->c); |
| 13655 | // Avoid race condition: |
| 13656 | // If a service gets a conflict, then we set the Conflict flag to tell us to generate |
| 13657 | // an mStatus_NameConflict message when we get the mStatus_MemFree for our PTR record. |
| 13658 | // If the client happens to deregister the service in the middle of that process, then |
| 13659 | // we clear the flag back to the normal state, so that we deliver a plain mStatus_MemFree |
| 13660 | // instead of incorrectly promoting it to mStatus_NameConflict. |
| 13661 | // This race condition is exposed particularly when the conformance test generates |
| 13662 | // a whole batch of simultaneous conflicts across a range of services all advertised |
| 13663 | // using the same system default name, and if we don't take this precaution then |
| 13664 | // we end up incrementing m->nicelabel multiple times instead of just once. |
| 13665 | // <rdar://problem/4060169> Bug when auto-renaming Computer Name after name collision |
| 13666 | sr->Conflict = mDNSfalse; |
| 13667 | return(mStatus_NoError); |
| 13668 | } |
| 13669 | else |
| 13670 | { |
| 13671 | mDNSu32 i; |
| 13672 | mStatus status; |
| 13673 | ExtraResourceRecord *e; |
| 13674 | mDNS_Lock(m); |
| 13675 | e = sr->Extras; |
| 13676 | |
| 13677 | // We use mDNS_Dereg_repeat because, in the event of a collision, some or all of the |
| 13678 | // SRV, TXT, or Extra records could have already been automatically deregistered, and that's okay |
| 13679 | mDNS_Deregister_internal(m, &sr->RR_SRV, mDNS_Dereg_repeat); |
| 13680 | mDNS_Deregister_internal(m, &sr->RR_TXT, mDNS_Dereg_repeat); |
| 13681 | |
| 13682 | mDNS_Deregister_internal(m, &sr->RR_ADV, drt); |
| 13683 | |
| 13684 | // We deregister all of the extra records, but we leave the sr->Extras list intact |
| 13685 | // in case the client wants to do a RenameAndReregister and reinstate the registration |
| 13686 | while (e) |
| 13687 | { |
| 13688 | mDNS_Deregister_internal(m, &e->r, mDNS_Dereg_repeat); |
| 13689 | e = e->next; |
| 13690 | } |
| 13691 | |
| 13692 | for (i=0; i<sr->NumSubTypes; i++) |
| 13693 | mDNS_Deregister_internal(m, &sr->SubTypes[i], drt); |
| 13694 | |
| 13695 | status = mDNS_Deregister_internal(m, &sr->RR_PTR, drt); |
| 13696 | mDNS_Unlock(m); |
| 13697 | return(status); |
| 13698 | } |
| 13699 | } |
| 13700 | |
| 13701 | // Create a registration that asserts that no such service exists with this name. |
| 13702 | // This can be useful where there is a given function is available through several protocols. |
| 13703 | // For example, a printer called "Stuart's Printer" may implement printing via the "pdl-datastream" and "IPP" |
| 13704 | // protocols, but not via "LPR". In this case it would be prudent for the printer to assert the non-existence of an |
| 13705 | // "LPR" service called "Stuart's Printer". Without this precaution, another printer than offers only "LPR" printing |
| 13706 | // could inadvertently advertise its service under the same name "Stuart's Printer", which might be confusing for users. |
| 13707 | mDNSexport mStatus mDNS_RegisterNoSuchService(mDNS *const m, AuthRecord *const rr, |
| 13708 | const domainlabel *const name, const domainname *const type, const domainname *const domain, |
| 13709 | const domainname *const host, |
| 13710 | const mDNSInterfaceID InterfaceID, mDNSRecordCallback Callback, void *Context, mDNSu32 flags) |
| 13711 | { |
| 13712 | AuthRecType artype; |
| 13713 | |
| 13714 | artype = setAuthRecType(InterfaceID, flags); |
| 13715 | |
| 13716 | mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_SRV, kHostNameTTL, kDNSRecordTypeUnique, artype, Callback, Context); |
| 13717 | if (ConstructServiceName(&rr->namestorage, name, type, domain) == mDNSNULL) return(mStatus_BadParamErr); |
| 13718 | rr->resrec.rdata->u.srv.priority = 0; |
| 13719 | rr->resrec.rdata->u.srv.weight = 0; |
| 13720 | rr->resrec.rdata->u.srv.port = zeroIPPort; |
| 13721 | if (host && host->c[0]) AssignDomainName(&rr->resrec.rdata->u.srv.target, host); |
| 13722 | else rr->AutoTarget = Target_AutoHost; |
| 13723 | return(mDNS_Register(m, rr)); |
| 13724 | } |
| 13725 | |
| 13726 | mDNSexport mStatus mDNS_AdvertiseDomains(mDNS *const m, AuthRecord *rr, |
| 13727 | mDNS_DomainType DomainType, const mDNSInterfaceID InterfaceID, char *domname) |
| 13728 | { |
| 13729 | AuthRecType artype; |
| 13730 | |
| 13731 | if (InterfaceID == mDNSInterface_LocalOnly) |
| 13732 | artype = AuthRecordLocalOnly; |
| 13733 | else if (InterfaceID == mDNSInterface_P2P || InterfaceID == mDNSInterface_BLE) |
| 13734 | artype = AuthRecordP2P; |
| 13735 | else |
| 13736 | artype = AuthRecordAny; |
| 13737 | mDNS_SetupResourceRecord(rr, mDNSNULL, InterfaceID, kDNSType_PTR, kStandardTTL, kDNSRecordTypeShared, artype, mDNSNULL, mDNSNULL); |
| 13738 | if (!MakeDomainNameFromDNSNameString(&rr->namestorage, mDNS_DomainTypeNames[DomainType])) return(mStatus_BadParamErr); |
| 13739 | if (!MakeDomainNameFromDNSNameString(&rr->resrec.rdata->u.name, domname)) return(mStatus_BadParamErr); |
| 13740 | return(mDNS_Register(m, rr)); |
| 13741 | } |
| 13742 | |
| 13743 | mDNSlocal mDNSBool mDNS_IdUsedInResourceRecordsList(mDNS * const m, mDNSOpaque16 id) |
| 13744 | { |
| 13745 | AuthRecord *r; |
| 13746 | for (r = m->ResourceRecords; r; r=r->next) if (mDNSSameOpaque16(id, r->updateid)) return mDNStrue; |
| 13747 | return mDNSfalse; |
| 13748 | } |
| 13749 | |
| 13750 | mDNSlocal mDNSBool mDNS_IdUsedInQuestionsList(mDNS * const m, mDNSOpaque16 id) |
| 13751 | { |
| 13752 | DNSQuestion *q; |
| 13753 | for (q = m->Questions; q; q=q->next) if (mDNSSameOpaque16(id, q->TargetQID)) return mDNStrue; |
| 13754 | return mDNSfalse; |
| 13755 | } |
| 13756 | |
| 13757 | mDNSexport mDNSOpaque16 mDNS_NewMessageID(mDNS * const m) |
| 13758 | { |
| 13759 | mDNSOpaque16 id; |
| 13760 | int i; |
| 13761 | |
| 13762 | for (i=0; i<10; i++) |
| 13763 | { |
| 13764 | id = mDNSOpaque16fromIntVal(1 + (mDNSu16)mDNSRandom(0xFFFE)); |
| 13765 | if (!mDNS_IdUsedInResourceRecordsList(m, id) && !mDNS_IdUsedInQuestionsList(m, id)) break; |
| 13766 | } |
| 13767 | |
| 13768 | debugf("mDNS_NewMessageID: %5d" , mDNSVal16(id)); |
| 13769 | |
| 13770 | return id; |
| 13771 | } |
| 13772 | |
| 13773 | // *************************************************************************** |
| 13774 | #if COMPILER_LIKES_PRAGMA_MARK |
| 13775 | #pragma mark - |
| 13776 | #pragma mark - Sleep Proxy Server |
| 13777 | #endif |
| 13778 | |
| 13779 | mDNSlocal void RestartARPProbing(mDNS *const m, AuthRecord *const rr) |
| 13780 | { |
| 13781 | // If we see an ARP from a machine we think is sleeping, then either |
| 13782 | // (i) the machine has woken, or |
| 13783 | // (ii) it's just a stray old packet from before the machine slept |
| 13784 | // To handle the second case, we reset ProbeCount, so we'll suppress our own answers for a while, to avoid |
| 13785 | // generating ARP conflicts with a waking machine, and set rr->LastAPTime so we'll start probing again in 10 seconds. |
| 13786 | // If the machine has just woken then we'll discard our records when we see the first new mDNS probe from that machine. |
| 13787 | // If it was a stray old packet, then after 10 seconds we'll probe again and then start answering ARPs again. In this case we *do* |
| 13788 | // need to send new ARP Announcements, because the owner's ARP broadcasts will have updated neighboring ARP caches, so we need to |
| 13789 | // re-assert our (temporary) ownership of that IP address in order to receive subsequent packets addressed to that IPv4 address. |
| 13790 | |
| 13791 | rr->resrec.RecordType = kDNSRecordTypeUnique; |
| 13792 | rr->ProbeCount = DefaultProbeCountForTypeUnique; |
| 13793 | rr->ProbeRestartCount++; |
| 13794 | |
| 13795 | // If we haven't started announcing yet (and we're not already in ten-second-delay mode) the machine is probably |
| 13796 | // still going to sleep, so we just reset rr->ProbeCount so we'll continue probing until it stops responding. |
| 13797 | // If we *have* started announcing, the machine is probably in the process of waking back up, so in that case |
| 13798 | // we're more cautious and we wait ten seconds before probing it again. We do this because while waking from |
| 13799 | // sleep, some network interfaces tend to lose or delay inbound packets, and without this delay, if the waking machine |
| 13800 | // didn't answer our three probes within three seconds then we'd announce and cause it an unnecessary address conflict. |
| 13801 | if (rr->AnnounceCount == InitialAnnounceCount && m->timenow - rr->LastAPTime >= 0) |
| 13802 | InitializeLastAPTime(m, rr); |
| 13803 | else |
| 13804 | { |
| 13805 | rr->AnnounceCount = InitialAnnounceCount; |
| 13806 | rr->ThisAPInterval = mDNSPlatformOneSecond; |
| 13807 | rr->LastAPTime = m->timenow + mDNSPlatformOneSecond * 9; // Send first packet at rr->LastAPTime + rr->ThisAPInterval, i.e. 10 seconds from now |
| 13808 | SetNextAnnounceProbeTime(m, rr); |
| 13809 | } |
| 13810 | } |
| 13811 | |
| 13812 | mDNSlocal void mDNSCoreReceiveRawARP(mDNS *const m, const ARP_EthIP *const arp, const mDNSInterfaceID InterfaceID) |
| 13813 | { |
| 13814 | static const mDNSOpaque16 ARP_op_request = { { 0, 1 } }; |
| 13815 | AuthRecord *rr; |
| 13816 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); |
| 13817 | if (!intf) return; |
| 13818 | |
| 13819 | mDNS_Lock(m); |
| 13820 | |
| 13821 | // Pass 1: |
| 13822 | // Process ARP Requests and Probes (but not Announcements), and generate an ARP Reply if necessary. |
| 13823 | // We also process ARPs from our own kernel (and 'answer' them by injecting a local ARP table entry) |
| 13824 | // We ignore ARP Announcements here -- Announcements are not questions, they're assertions, so we don't need to answer them. |
| 13825 | // The times we might need to react to an ARP Announcement are: |
| 13826 | // (i) as an indication that the host in question has not gone to sleep yet (so we should delay beginning to proxy for it) or |
| 13827 | // (ii) if it's a conflicting Announcement from another host |
| 13828 | // -- and we check for these in Pass 2 below. |
| 13829 | if (mDNSSameOpaque16(arp->op, ARP_op_request) && !mDNSSameIPv4Address(arp->spa, arp->tpa)) |
| 13830 | { |
| 13831 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 13832 | if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && |
| 13833 | rr->AddressProxy.type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->AddressProxy.ip.v4, arp->tpa)) |
| 13834 | { |
| 13835 | static const char msg1[] = "ARP Req from owner -- re-probing" ; |
| 13836 | static const char msg2[] = "Ignoring ARP Request from " ; |
| 13837 | static const char msg3[] = "Creating Local ARP Cache entry " ; |
| 13838 | static const char msg4[] = "Answering ARP Request from " ; |
| 13839 | const char *const msg = mDNSSameEthAddress(&arp->sha, &rr->WakeUp.IMAC) ? msg1 : |
| 13840 | (rr->AnnounceCount == InitialAnnounceCount) ? msg2 : |
| 13841 | mDNSSameEthAddress(&arp->sha, &intf->MAC) ? msg3 : msg4; |
| 13842 | LogMsg("Arp %-7s %s %.6a %.4a for %.4a -- H-MAC %.6a I-MAC %.6a %s" , |
| 13843 | intf->ifname, msg, arp->sha.b, arp->spa.b, arp->tpa.b, |
| 13844 | &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 13845 | if (msg == msg1) |
| 13846 | { |
| 13847 | if ( rr->ProbeRestartCount < MAX_PROBE_RESTARTS) |
| 13848 | RestartARPProbing(m, rr); |
| 13849 | else |
| 13850 | LogSPS("Reached maximum number of restarts for probing - %s" , ARDisplayString(m,rr)); |
| 13851 | } |
| 13852 | else if (msg == msg3) |
| 13853 | { |
| 13854 | mDNSPlatformSetLocalAddressCacheEntry(&rr->AddressProxy, &rr->WakeUp.IMAC, InterfaceID); |
| 13855 | } |
| 13856 | else if (msg == msg4) |
| 13857 | { |
| 13858 | SendARP(m, 2, rr, (mDNSv4Addr *)arp->tpa.b, &arp->sha, (mDNSv4Addr *)arp->spa.b, &arp->sha); |
| 13859 | } |
| 13860 | } |
| 13861 | } |
| 13862 | |
| 13863 | // Pass 2: |
| 13864 | // For all types of ARP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding. |
| 13865 | // (Strictly speaking we're only checking Announcement/Request/Reply packets, since ARP Probes have zero Sender IP address, |
| 13866 | // so by definition (and by design) they can never conflict with any real (i.e. non-zero) IP address). |
| 13867 | // We ignore ARPs we sent ourselves (Sender MAC address is our MAC address) because our own proxy ARPs do not constitute a conflict that we need to handle. |
| 13868 | // If we see an apparently conflicting ARP, we check the sender hardware address: |
| 13869 | // If the sender hardware address is the original owner this is benign, so we just suppress our own proxy answering for a while longer. |
| 13870 | // If the sender hardware address is *not* the original owner, then this is a conflict, and we need to wake the sleeping machine to handle it. |
| 13871 | if (mDNSSameEthAddress(&arp->sha, &intf->MAC)) |
| 13872 | debugf("ARP from self for %.4a" , arp->tpa.b); |
| 13873 | else |
| 13874 | { |
| 13875 | if (!mDNSSameIPv4Address(arp->spa, zerov4Addr)) |
| 13876 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 13877 | if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && |
| 13878 | rr->AddressProxy.type == mDNSAddrType_IPv4 && mDNSSameIPv4Address(rr->AddressProxy.ip.v4, arp->spa) && (rr->ProbeRestartCount < MAX_PROBE_RESTARTS)) |
| 13879 | { |
| 13880 | if (mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC)) |
| 13881 | { |
| 13882 | LogMsg("%-7s ARP from %.6a %.4a for %.4a -- Invalid H-MAC %.6a I-MAC %.6a %s" , intf->ifname, |
| 13883 | arp->sha.b, arp->spa.b, arp->tpa.b, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 13884 | } |
| 13885 | else |
| 13886 | { |
| 13887 | RestartARPProbing(m, rr); |
| 13888 | if (mDNSSameEthAddress(&arp->sha, &rr->WakeUp.IMAC)) |
| 13889 | { |
| 13890 | LogMsg("%-7s ARP %s from owner %.6a %.4a for %-15.4a -- re-starting probing for %s" , intf->ifname, |
| 13891 | mDNSSameIPv4Address(arp->spa, arp->tpa) ? "Announcement " : mDNSSameOpaque16(arp->op, ARP_op_request) ? "Request " : "Response " , |
| 13892 | arp->sha.b, arp->spa.b, arp->tpa.b, ARDisplayString(m, rr)); |
| 13893 | } |
| 13894 | else |
| 13895 | { |
| 13896 | LogMsg("%-7s Conflicting ARP from %.6a %.4a for %.4a -- waking H-MAC %.6a I-MAC %.6a %s" , intf->ifname, |
| 13897 | arp->sha.b, arp->spa.b, arp->tpa.b, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 13898 | ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC); |
| 13899 | } |
| 13900 | } |
| 13901 | } |
| 13902 | } |
| 13903 | |
| 13904 | mDNS_Unlock(m); |
| 13905 | } |
| 13906 | |
| 13907 | /* |
| 13908 | // Option 1 is Source Link Layer Address Option |
| 13909 | // Option 2 is Target Link Layer Address Option |
| 13910 | mDNSlocal const mDNSEthAddr *GetLinkLayerAddressOption(const IPv6NDP *const ndp, const mDNSu8 *const end, mDNSu8 op) |
| 13911 | { |
| 13912 | const mDNSu8 *options = (mDNSu8 *)(ndp+1); |
| 13913 | while (options < end) |
| 13914 | { |
| 13915 | debugf("NDP Option %02X len %2d %d", options[0], options[1], end - options); |
| 13916 | if (options[0] == op && options[1] == 1) return (const mDNSEthAddr*)(options+2); |
| 13917 | options += options[1] * 8; |
| 13918 | } |
| 13919 | return mDNSNULL; |
| 13920 | } |
| 13921 | */ |
| 13922 | |
| 13923 | mDNSlocal void mDNSCoreReceiveRawND(mDNS *const m, const mDNSEthAddr *const sha, const mDNSv6Addr *spa, |
| 13924 | const IPv6NDP *const ndp, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID) |
| 13925 | { |
| 13926 | AuthRecord *rr; |
| 13927 | NetworkInterfaceInfo *intf = FirstInterfaceForID(m, InterfaceID); |
| 13928 | if (!intf) return; |
| 13929 | |
| 13930 | mDNS_Lock(m); |
| 13931 | |
| 13932 | // Pass 1: Process Neighbor Solicitations, and generate a Neighbor Advertisement if necessary. |
| 13933 | if (ndp->type == NDP_Sol) |
| 13934 | { |
| 13935 | //const mDNSEthAddr *const sha = GetLinkLayerAddressOption(ndp, end, NDP_SrcLL); |
| 13936 | (void)end; |
| 13937 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 13938 | if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && |
| 13939 | rr->AddressProxy.type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->AddressProxy.ip.v6, ndp->target)) |
| 13940 | { |
| 13941 | static const char msg1[] = "NDP Req from owner -- re-probing" ; |
| 13942 | static const char msg2[] = "Ignoring NDP Request from " ; |
| 13943 | static const char msg3[] = "Creating Local NDP Cache entry " ; |
| 13944 | static const char msg4[] = "Answering NDP Request from " ; |
| 13945 | static const char msg5[] = "Answering NDP Probe from " ; |
| 13946 | const char *const msg = sha && mDNSSameEthAddress(sha, &rr->WakeUp.IMAC) ? msg1 : |
| 13947 | (rr->AnnounceCount == InitialAnnounceCount) ? msg2 : |
| 13948 | sha && mDNSSameEthAddress(sha, &intf->MAC) ? msg3 : |
| 13949 | spa && mDNSIPv6AddressIsZero(*spa) ? msg4 : msg5; |
| 13950 | LogSPS("%-7s %s %.6a %.16a for %.16a -- H-MAC %.6a I-MAC %.6a %s" , |
| 13951 | intf->ifname, msg, sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 13952 | if (msg == msg1) |
| 13953 | { |
| 13954 | if (rr->ProbeRestartCount < MAX_PROBE_RESTARTS) |
| 13955 | RestartARPProbing(m, rr); |
| 13956 | else |
| 13957 | LogSPS("Reached maximum number of restarts for probing - %s" , ARDisplayString(m,rr)); |
| 13958 | } |
| 13959 | else if (msg == msg3) |
| 13960 | mDNSPlatformSetLocalAddressCacheEntry(&rr->AddressProxy, &rr->WakeUp.IMAC, InterfaceID); |
| 13961 | else if (msg == msg4) |
| 13962 | SendNDP(m, NDP_Adv, NDP_Solicited, rr, &ndp->target, mDNSNULL, spa, sha); |
| 13963 | else if (msg == msg5) |
| 13964 | SendNDP(m, NDP_Adv, 0, rr, &ndp->target, mDNSNULL, &AllHosts_v6, &AllHosts_v6_Eth); |
| 13965 | } |
| 13966 | } |
| 13967 | |
| 13968 | // Pass 2: For all types of NDP packet we check the Sender IP address to make sure it doesn't conflict with any AddressProxy record we're holding. |
| 13969 | if (mDNSSameEthAddress(sha, &intf->MAC)) |
| 13970 | debugf("NDP from self for %.16a" , &ndp->target); |
| 13971 | else |
| 13972 | { |
| 13973 | // For Neighbor Advertisements we check the Target address field, not the actual IPv6 source address. |
| 13974 | // When a machine has both link-local and routable IPv6 addresses, it may send NDP packets making assertions |
| 13975 | // about its routable IPv6 address, using its link-local address as the source address for all NDP packets. |
| 13976 | // Hence it is the NDP target address we care about, not the actual packet source address. |
| 13977 | if (ndp->type == NDP_Adv) spa = &ndp->target; |
| 13978 | if (!mDNSSameIPv6Address(*spa, zerov6Addr)) |
| 13979 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 13980 | if (rr->resrec.InterfaceID == InterfaceID && rr->resrec.RecordType != kDNSRecordTypeDeregistering && |
| 13981 | rr->AddressProxy.type == mDNSAddrType_IPv6 && mDNSSameIPv6Address(rr->AddressProxy.ip.v6, *spa) && (rr->ProbeRestartCount < MAX_PROBE_RESTARTS)) |
| 13982 | { |
| 13983 | if (mDNSSameEthAddress(&zeroEthAddr, &rr->WakeUp.HMAC)) |
| 13984 | { |
| 13985 | LogSPS("%-7s NDP from %.6a %.16a for %.16a -- Invalid H-MAC %.6a I-MAC %.6a %s" , intf->ifname, |
| 13986 | sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 13987 | } |
| 13988 | else |
| 13989 | { |
| 13990 | RestartARPProbing(m, rr); |
| 13991 | if (mDNSSameEthAddress(sha, &rr->WakeUp.IMAC)) |
| 13992 | { |
| 13993 | LogSPS("%-7s NDP %s from owner %.6a %.16a for %.16a -- re-starting probing for %s" , intf->ifname, |
| 13994 | ndp->type == NDP_Sol ? "Solicitation " : "Advertisement" , sha, spa, &ndp->target, ARDisplayString(m, rr)); |
| 13995 | } |
| 13996 | else |
| 13997 | { |
| 13998 | LogMsg("%-7s Conflicting NDP from %.6a %.16a for %.16a -- waking H-MAC %.6a I-MAC %.6a %s" , intf->ifname, |
| 13999 | sha, spa, &ndp->target, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, rr)); |
| 14000 | ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC); |
| 14001 | } |
| 14002 | } |
| 14003 | } |
| 14004 | } |
| 14005 | |
| 14006 | mDNS_Unlock(m); |
| 14007 | } |
| 14008 | |
| 14009 | mDNSlocal void mDNSCoreReceiveRawTransportPacket(mDNS *const m, const mDNSEthAddr *const sha, const mDNSAddr *const src, const mDNSAddr *const dst, const mDNSu8 protocol, |
| 14010 | const mDNSu8 *const p, const TransportLayerPacket *const t, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID, const mDNSu16 len) |
| 14011 | { |
| 14012 | const mDNSIPPort port = (protocol == 0x06) ? t->tcp.dst : (protocol == 0x11) ? t->udp.dst : zeroIPPort; |
| 14013 | mDNSBool wake = mDNSfalse; |
| 14014 | mDNSBool kaWake = mDNSfalse; |
| 14015 | |
| 14016 | switch (protocol) |
| 14017 | { |
| 14018 | #define XX wake ? "Received" : "Ignoring", end-p |
| 14019 | case 0x01: LogSPS("Ignoring %d-byte ICMP from %#a to %#a" , end-p, src, dst); |
| 14020 | break; |
| 14021 | |
| 14022 | case 0x06: { |
| 14023 | AuthRecord *kr; |
| 14024 | mDNSu32 seq, ack; |
| 14025 | #define TH_FIN 0x01 |
| 14026 | #define TH_SYN 0x02 |
| 14027 | #define TH_RST 0x04 |
| 14028 | #define TH_ACK 0x10 |
| 14029 | |
| 14030 | kr = mDNS_MatchKeepaliveInfo(m, dst, src, port, t->tcp.src, &seq, &ack); |
| 14031 | if (kr) |
| 14032 | { |
| 14033 | LogSPS("mDNSCoreReceiveRawTransportPacket: Found a Keepalive record from %#a:%d to %#a:%d" , src, mDNSVal16(t->tcp.src), dst, mDNSVal16(port)); |
| 14034 | // Plan to wake if |
| 14035 | // (a) RST or FIN is set (the keepalive that we sent could have caused a reset) |
| 14036 | // (b) packet that contains new data and acks a sequence number higher than the one |
| 14037 | // we have been sending in the keepalive |
| 14038 | |
| 14039 | wake = ((t->tcp.flags & TH_RST) || (t->tcp.flags & TH_FIN)) ; |
| 14040 | if (!wake) |
| 14041 | { |
| 14042 | mDNSu8 *ptr; |
| 14043 | mDNSu32 pseq, pack; |
| 14044 | mDNSBool data = mDNSfalse; |
| 14045 | mDNSu8 tcphlen; |
| 14046 | |
| 14047 | // Convert to host order |
| 14048 | ptr = (mDNSu8 *)&seq; |
| 14049 | seq = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; |
| 14050 | |
| 14051 | ptr = (mDNSu8 *)&ack; |
| 14052 | ack = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; |
| 14053 | |
| 14054 | pseq = t->tcp.seq; |
| 14055 | ptr = (mDNSu8 *)&pseq; |
| 14056 | pseq = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; |
| 14057 | |
| 14058 | pack = t->tcp.ack; |
| 14059 | ptr = (mDNSu8 *)&pack; |
| 14060 | pack = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; |
| 14061 | |
| 14062 | // If the other side is acking one more than our sequence number (keepalive is one |
| 14063 | // less than the last valid sequence sent) and it's sequence is more than what we |
| 14064 | // acked before |
| 14065 | //if (end - p - 34 - ((t->tcp.offset >> 4) * 4) > 0) data = mDNStrue; |
| 14066 | tcphlen = ((t->tcp.offset >> 4) * 4); |
| 14067 | if (end - ((mDNSu8 *)t + tcphlen) > 0) data = mDNStrue; |
| 14068 | wake = ((int)(pack - seq) > 0) && ((int)(pseq - ack) >= 0) && data; |
| 14069 | |
| 14070 | // If we got a regular keepalive on a connection that was registed with the KeepAlive API, respond with an ACK |
| 14071 | if ((t->tcp.flags & TH_ACK) && (data == mDNSfalse) && |
| 14072 | ((int)(ack - pseq) == 1)) |
| 14073 | { |
| 14074 | // Send an ACK; |
| 14075 | mDNS_SendKeepaliveACK(m, kr); |
| 14076 | } |
| 14077 | LogSPS("mDNSCoreReceiveRawTransportPacket: End %p, hlen %d, Datalen %d, pack %u, seq %u, pseq %u, ack %u, wake %d" , |
| 14078 | end, tcphlen, end - ((mDNSu8 *)t + tcphlen), pack, seq, pseq, ack, wake); |
| 14079 | } |
| 14080 | else { LogSPS("mDNSCoreReceiveRawTransportPacket: waking because of RST or FIN th_flags %d" , t->tcp.flags); } |
| 14081 | kaWake = wake; |
| 14082 | } |
| 14083 | else |
| 14084 | { |
| 14085 | // Plan to wake if |
| 14086 | // (a) RST is not set, AND |
| 14087 | // (b) packet is SYN, SYN+FIN, or plain data packet (no SYN or FIN). We won't wake for FIN alone. |
| 14088 | wake = (!(t->tcp.flags & TH_RST) && (t->tcp.flags & (TH_FIN|TH_SYN)) != TH_FIN); |
| 14089 | |
| 14090 | // For now, to reduce spurious wakeups, we wake only for TCP SYN, |
| 14091 | // except for ssh connections, where we'll wake for plain data packets too |
| 14092 | if (!mDNSSameIPPort(port, SSHPort) && !(t->tcp.flags & 2)) wake = mDNSfalse; |
| 14093 | |
| 14094 | LogSPS("%s %d-byte TCP from %#a:%d to %#a:%d%s%s%s" , XX, |
| 14095 | src, mDNSVal16(t->tcp.src), dst, mDNSVal16(port), |
| 14096 | (t->tcp.flags & 2) ? " SYN" : "" , |
| 14097 | (t->tcp.flags & 1) ? " FIN" : "" , |
| 14098 | (t->tcp.flags & 4) ? " RST" : "" ); |
| 14099 | } |
| 14100 | break; |
| 14101 | } |
| 14102 | |
| 14103 | case 0x11: { |
| 14104 | #define ARD_AsNumber 3283 |
| 14105 | static const mDNSIPPort ARD = { { ARD_AsNumber >> 8, ARD_AsNumber & 0xFF } }; |
| 14106 | const mDNSu16 udplen = (mDNSu16)((mDNSu16)t->bytes[4] << 8 | t->bytes[5]); // Length *including* 8-byte UDP header |
| 14107 | if (udplen >= sizeof(UDPHeader)) |
| 14108 | { |
| 14109 | const mDNSu16 datalen = udplen - sizeof(UDPHeader); |
| 14110 | wake = mDNStrue; |
| 14111 | |
| 14112 | // For Back to My Mac UDP port 4500 (IPSEC) packets, we do some special handling |
| 14113 | if (mDNSSameIPPort(port, IPSECPort)) |
| 14114 | { |
| 14115 | // Specifically ignore NAT keepalive packets |
| 14116 | if (datalen == 1 && end >= &t->bytes[9] && t->bytes[8] == 0xFF) wake = mDNSfalse; |
| 14117 | else |
| 14118 | { |
| 14119 | // Skip over the Non-ESP Marker if present |
| 14120 | const mDNSBool NonESP = (end >= &t->bytes[12] && t->bytes[8] == 0 && t->bytes[9] == 0 && t->bytes[10] == 0 && t->bytes[11] == 0); |
| 14121 | const IKEHeader *const ike = (IKEHeader *)(t + (NonESP ? 12 : 8)); |
| 14122 | const mDNSu16 ikelen = datalen - (NonESP ? 4 : 0); |
| 14123 | if (ikelen >= sizeof(IKEHeader) && end >= ((mDNSu8 *)ike) + sizeof(IKEHeader)) |
| 14124 | if ((ike->Version & 0x10) == 0x10) |
| 14125 | { |
| 14126 | // ExchangeType == 5 means 'Informational' <http://www.ietf.org/rfc/rfc2408.txt> |
| 14127 | // ExchangeType == 34 means 'IKE_SA_INIT' <http://www.iana.org/assignments/ikev2-parameters> |
| 14128 | if (ike->ExchangeType == 5 || ike->ExchangeType == 34) wake = mDNSfalse; |
| 14129 | LogSPS("%s %d-byte IKE ExchangeType %d" , XX, ike->ExchangeType); |
| 14130 | } |
| 14131 | } |
| 14132 | } |
| 14133 | |
| 14134 | // For now, because we haven't yet worked out a clean elegant way to do this, we just special-case the |
| 14135 | // Apple Remote Desktop port number -- we ignore all packets to UDP 3283 (the "Net Assistant" port), |
| 14136 | // except for Apple Remote Desktop's explicit manual wakeup packet, which looks like this: |
| 14137 | // UDP header (8 bytes) |
| 14138 | // Payload: 13 88 00 6a 41 4e 41 20 (8 bytes) ffffffffffff (6 bytes) 16xMAC (96 bytes) = 110 bytes total |
| 14139 | if (mDNSSameIPPort(port, ARD)) wake = (datalen >= 110 && end >= &t->bytes[10] && t->bytes[8] == 0x13 && t->bytes[9] == 0x88); |
| 14140 | |
| 14141 | LogSPS("%s %d-byte UDP from %#a:%d to %#a:%d" , XX, src, mDNSVal16(t->udp.src), dst, mDNSVal16(port)); |
| 14142 | } |
| 14143 | } |
| 14144 | break; |
| 14145 | |
| 14146 | case 0x3A: if (&t->bytes[len] <= end) |
| 14147 | { |
| 14148 | mDNSu16 checksum = IPv6CheckSum(&src->ip.v6, &dst->ip.v6, protocol, t->bytes, len); |
| 14149 | if (!checksum) mDNSCoreReceiveRawND(m, sha, &src->ip.v6, &t->ndp, &t->bytes[len], InterfaceID); |
| 14150 | else LogInfo("IPv6CheckSum bad %04X %02X%02X from %#a to %#a" , checksum, t->bytes[2], t->bytes[3], src, dst); |
| 14151 | } |
| 14152 | break; |
| 14153 | |
| 14154 | default: LogSPS("Ignoring %d-byte IP packet unknown protocol %d from %#a to %#a" , end-p, protocol, src, dst); |
| 14155 | break; |
| 14156 | } |
| 14157 | |
| 14158 | if (wake) |
| 14159 | { |
| 14160 | AuthRecord *rr, *r2; |
| 14161 | |
| 14162 | mDNS_Lock(m); |
| 14163 | for (rr = m->ResourceRecords; rr; rr=rr->next) |
| 14164 | if (rr->resrec.InterfaceID == InterfaceID && |
| 14165 | rr->resrec.RecordType != kDNSRecordTypeDeregistering && |
| 14166 | rr->AddressProxy.type && mDNSSameAddress(&rr->AddressProxy, dst)) |
| 14167 | { |
| 14168 | const mDNSu8 *const tp = (protocol == 6) ? (const mDNSu8 *)"\x4_tcp" : (const mDNSu8 *)"\x4_udp" ; |
| 14169 | for (r2 = m->ResourceRecords; r2; r2=r2->next) |
| 14170 | if (r2->resrec.InterfaceID == InterfaceID && mDNSSameEthAddress(&r2->WakeUp.HMAC, &rr->WakeUp.HMAC) && |
| 14171 | r2->resrec.RecordType != kDNSRecordTypeDeregistering && |
| 14172 | r2->resrec.rrtype == kDNSType_SRV && mDNSSameIPPort(r2->resrec.rdata->u.srv.port, port) && |
| 14173 | SameDomainLabel(ThirdLabel(r2->resrec.name)->c, tp)) |
| 14174 | break; |
| 14175 | if (!r2 && mDNSSameIPPort(port, IPSECPort)) r2 = rr; // So that we wake for BTMM IPSEC packets, even without a matching SRV record |
| 14176 | if (!r2 && kaWake) r2 = rr; // So that we wake for keepalive packets, even without a matching SRV record |
| 14177 | if (r2) |
| 14178 | { |
| 14179 | LogMsg("Waking host at %s %#a H-MAC %.6a I-MAC %.6a for %s" , |
| 14180 | InterfaceNameForID(m, rr->resrec.InterfaceID), dst, &rr->WakeUp.HMAC, &rr->WakeUp.IMAC, ARDisplayString(m, r2)); |
| 14181 | ScheduleWakeup(m, rr->resrec.InterfaceID, &rr->WakeUp.HMAC); |
| 14182 | } |
| 14183 | else |
| 14184 | LogSPS("Sleeping host at %s %#a %.6a has no service on %#s %d" , |
| 14185 | InterfaceNameForID(m, rr->resrec.InterfaceID), dst, &rr->WakeUp.HMAC, tp, mDNSVal16(port)); |
| 14186 | } |
| 14187 | mDNS_Unlock(m); |
| 14188 | } |
| 14189 | } |
| 14190 | |
| 14191 | mDNSexport void mDNSCoreReceiveRawPacket(mDNS *const m, const mDNSu8 *const p, const mDNSu8 *const end, const mDNSInterfaceID InterfaceID) |
| 14192 | { |
| 14193 | static const mDNSOpaque16 Ethertype_ARP = { { 0x08, 0x06 } }; // Ethertype 0x0806 = ARP |
| 14194 | static const mDNSOpaque16 Ethertype_IPv4 = { { 0x08, 0x00 } }; // Ethertype 0x0800 = IPv4 |
| 14195 | static const mDNSOpaque16 Ethertype_IPv6 = { { 0x86, 0xDD } }; // Ethertype 0x86DD = IPv6 |
| 14196 | static const mDNSOpaque16 ARP_hrd_eth = { { 0x00, 0x01 } }; // Hardware address space (Ethernet = 1) |
| 14197 | static const mDNSOpaque16 ARP_pro_ip = { { 0x08, 0x00 } }; // Protocol address space (IP = 0x0800) |
| 14198 | |
| 14199 | // Note: BPF guarantees that the NETWORK LAYER header will be word aligned, not the link-layer header. |
| 14200 | // In other words, we can safely assume that pkt below (ARP, IPv4 or IPv6) is properly word aligned, |
| 14201 | // but if pkt is 4-byte aligned, that necessarily means that eth CANNOT also be 4-byte aligned |
| 14202 | // since it points to a an address 14 bytes before pkt. |
| 14203 | const EthernetHeader *const eth = (const EthernetHeader *)p; |
| 14204 | const NetworkLayerPacket *const pkt = (const NetworkLayerPacket *)(eth+1); |
| 14205 | mDNSAddr src, dst; |
| 14206 | #define RequiredCapLen(P) ((P)==0x01 ? 4 : (P)==0x06 ? 20 : (P)==0x11 ? 8 : (P)==0x3A ? 24 : 0) |
| 14207 | |
| 14208 | // Is ARP? Length must be at least 14 + 28 = 42 bytes |
| 14209 | if (end >= p+42 && mDNSSameOpaque16(eth->ethertype, Ethertype_ARP) && mDNSSameOpaque16(pkt->arp.hrd, ARP_hrd_eth) && mDNSSameOpaque16(pkt->arp.pro, ARP_pro_ip)) |
| 14210 | mDNSCoreReceiveRawARP(m, &pkt->arp, InterfaceID); |
| 14211 | // Is IPv4 with zero fragmentation offset? Length must be at least 14 + 20 = 34 bytes |
| 14212 | else if (end >= p+34 && mDNSSameOpaque16(eth->ethertype, Ethertype_IPv4) && (pkt->v4.flagsfrags.b[0] & 0x1F) == 0 && pkt->v4.flagsfrags.b[1] == 0) |
| 14213 | { |
| 14214 | const mDNSu8 *const trans = p + 14 + (pkt->v4.vlen & 0xF) * 4; |
| 14215 | const mDNSu8 * transEnd = p + 14 + mDNSVal16(pkt->v4.totlen); |
| 14216 | if (transEnd > end) transEnd = end; |
| 14217 | debugf("Got IPv4 %02X from %.4a to %.4a" , pkt->v4.protocol, &pkt->v4.src, &pkt->v4.dst); |
| 14218 | src.type = mDNSAddrType_IPv4; src.ip.v4 = pkt->v4.src; |
| 14219 | dst.type = mDNSAddrType_IPv4; dst.ip.v4 = pkt->v4.dst; |
| 14220 | if (transEnd >= trans + RequiredCapLen(pkt->v4.protocol)) |
| 14221 | mDNSCoreReceiveRawTransportPacket(m, ð->src, &src, &dst, pkt->v4.protocol, p, (TransportLayerPacket*)trans, transEnd, InterfaceID, 0); |
| 14222 | } |
| 14223 | // Is IPv6? Length must be at least 14 + 28 = 42 bytes |
| 14224 | else if (end >= p+54 && mDNSSameOpaque16(eth->ethertype, Ethertype_IPv6)) |
| 14225 | { |
| 14226 | const mDNSu8 *const trans = p + 54; |
| 14227 | debugf("Got IPv6 %02X from %.16a to %.16a" , pkt->v6.pro, &pkt->v6.src, &pkt->v6.dst); |
| 14228 | src.type = mDNSAddrType_IPv6; src.ip.v6 = pkt->v6.src; |
| 14229 | dst.type = mDNSAddrType_IPv6; dst.ip.v6 = pkt->v6.dst; |
| 14230 | if (end >= trans + RequiredCapLen(pkt->v6.pro)) |
| 14231 | mDNSCoreReceiveRawTransportPacket(m, ð->src, &src, &dst, pkt->v6.pro, p, (TransportLayerPacket*)trans, end, InterfaceID, |
| 14232 | (mDNSu16)pkt->bytes[4] << 8 | pkt->bytes[5]); |
| 14233 | } |
| 14234 | } |
| 14235 | |
| 14236 | mDNSlocal void ConstructSleepProxyServerName(mDNS *const m, domainlabel *name) |
| 14237 | { |
| 14238 | name->c[0] = (mDNSu8)mDNS_snprintf((char*)name->c+1, 62, "%d-%d-%d-%d.%d %#s" , |
| 14239 | m->SPSType, m->SPSPortability, m->SPSMarginalPower, m->SPSTotalPower, m->SPSFeatureFlags, &m->nicelabel); |
| 14240 | } |
| 14241 | |
| 14242 | #ifndef SPC_DISABLED |
| 14243 | mDNSlocal void SleepProxyServerCallback(mDNS *const m, ServiceRecordSet *const srs, mStatus result) |
| 14244 | { |
| 14245 | if (result == mStatus_NameConflict) |
| 14246 | mDNS_RenameAndReregisterService(m, srs, mDNSNULL); |
| 14247 | else if (result == mStatus_MemFree) |
| 14248 | { |
| 14249 | if (m->SleepState) |
| 14250 | m->SPSState = 3; |
| 14251 | else |
| 14252 | { |
| 14253 | m->SPSState = (mDNSu8)(m->SPSSocket != mDNSNULL); |
| 14254 | if (m->SPSState) |
| 14255 | { |
| 14256 | domainlabel name; |
| 14257 | ConstructSleepProxyServerName(m, &name); |
| 14258 | mDNS_RegisterService(m, srs, |
| 14259 | &name, &SleepProxyServiceType, &localdomain, |
| 14260 | mDNSNULL, m->SPSSocket->port, // Host, port |
| 14261 | (mDNSu8 *)"" , 1, // TXT data, length |
| 14262 | mDNSNULL, 0, // Subtypes (none) |
| 14263 | mDNSInterface_Any, // Interface ID |
| 14264 | SleepProxyServerCallback, mDNSNULL, 0); // Callback, context, flags |
| 14265 | } |
| 14266 | LogSPS("Sleep Proxy Server %#s %s" , srs->RR_SRV.resrec.name->c, m->SPSState ? "started" : "stopped" ); |
| 14267 | } |
| 14268 | } |
| 14269 | } |
| 14270 | #endif |
| 14271 | |
| 14272 | // Called with lock held |
| 14273 | mDNSexport void mDNSCoreBeSleepProxyServer_internal(mDNS *const m, mDNSu8 sps, mDNSu8 port, mDNSu8 marginalpower, mDNSu8 totpower, mDNSu8 features) |
| 14274 | { |
| 14275 | // This routine uses mDNS_DeregisterService and calls SleepProxyServerCallback, so we execute in user callback context |
| 14276 | mDNS_DropLockBeforeCallback(); |
| 14277 | |
| 14278 | // If turning off SPS, close our socket |
| 14279 | // (Do this first, BEFORE calling mDNS_DeregisterService below) |
| 14280 | if (!sps && m->SPSSocket) { mDNSPlatformUDPClose(m->SPSSocket); m->SPSSocket = mDNSNULL; } |
| 14281 | |
| 14282 | // If turning off, or changing type, deregister old name |
| 14283 | #ifndef SPC_DISABLED |
| 14284 | if (m->SPSState == 1 && sps != m->SPSType) |
| 14285 | { m->SPSState = 2; mDNS_DeregisterService_drt(m, &m->SPSRecords, sps ? mDNS_Dereg_rapid : mDNS_Dereg_normal); } |
| 14286 | #endif // SPC_DISABLED |
| 14287 | |
| 14288 | // Record our new SPS parameters |
| 14289 | m->SPSType = sps; |
| 14290 | m->SPSPortability = port; |
| 14291 | m->SPSMarginalPower = marginalpower; |
| 14292 | m->SPSTotalPower = totpower; |
| 14293 | m->SPSFeatureFlags = features; |
| 14294 | // If turning on, open socket and advertise service |
| 14295 | if (sps) |
| 14296 | { |
| 14297 | if (!m->SPSSocket) |
| 14298 | { |
| 14299 | m->SPSSocket = mDNSPlatformUDPSocket(zeroIPPort); |
| 14300 | if (!m->SPSSocket) { LogMsg("mDNSCoreBeSleepProxyServer: Failed to allocate SPSSocket" ); goto fail; } |
| 14301 | } |
| 14302 | #ifndef SPC_DISABLED |
| 14303 | if (m->SPSState == 0) SleepProxyServerCallback(m, &m->SPSRecords, mStatus_MemFree); |
| 14304 | #endif // SPC_DISABLED |
| 14305 | } |
| 14306 | else if (m->SPSState) |
| 14307 | { |
| 14308 | LogSPS("mDNSCoreBeSleepProxyServer turning off from state %d; will wake clients" , m->SPSState); |
| 14309 | m->NextScheduledSPS = m->timenow; |
| 14310 | } |
| 14311 | fail: |
| 14312 | mDNS_ReclaimLockAfterCallback(); |
| 14313 | } |
| 14314 | |
| 14315 | // *************************************************************************** |
| 14316 | #if COMPILER_LIKES_PRAGMA_MARK |
| 14317 | #pragma mark - |
| 14318 | #pragma mark - Startup and Shutdown |
| 14319 | #endif |
| 14320 | |
| 14321 | mDNSlocal void mDNS_GrowCache_internal(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords) |
| 14322 | { |
| 14323 | if (storage && numrecords) |
| 14324 | { |
| 14325 | mDNSu32 i; |
| 14326 | debugf("Adding cache storage for %d more records (%d bytes)" , numrecords, numrecords*sizeof(CacheEntity)); |
| 14327 | for (i=0; i<numrecords; i++) storage[i].next = &storage[i+1]; |
| 14328 | storage[numrecords-1].next = m->rrcache_free; |
| 14329 | m->rrcache_free = storage; |
| 14330 | m->rrcache_size += numrecords; |
| 14331 | } |
| 14332 | } |
| 14333 | |
| 14334 | mDNSexport void mDNS_GrowCache(mDNS *const m, CacheEntity *storage, mDNSu32 numrecords) |
| 14335 | { |
| 14336 | mDNS_Lock(m); |
| 14337 | mDNS_GrowCache_internal(m, storage, numrecords); |
| 14338 | mDNS_Unlock(m); |
| 14339 | } |
| 14340 | |
| 14341 | mDNSlocal mStatus mDNS_InitStorage(mDNS *const m, mDNS_PlatformSupport *const p, |
| 14342 | CacheEntity *rrcachestorage, mDNSu32 rrcachesize, |
| 14343 | mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context) |
| 14344 | { |
| 14345 | mDNSu32 slot; |
| 14346 | mDNSs32 timenow; |
| 14347 | mStatus result; |
| 14348 | |
| 14349 | if (!rrcachestorage) rrcachesize = 0; |
| 14350 | |
| 14351 | m->p = p; |
| 14352 | m->NetworkChanged = 0; |
| 14353 | m->CanReceiveUnicastOn5353 = mDNSfalse; // Assume we can't receive unicasts on 5353, unless platform layer tells us otherwise |
| 14354 | m->AdvertiseLocalAddresses = AdvertiseLocalAddresses; |
| 14355 | m->DivertMulticastAdvertisements = mDNSfalse; |
| 14356 | m->mDNSPlatformStatus = mStatus_Waiting; |
| 14357 | m->UnicastPort4 = zeroIPPort; |
| 14358 | m->UnicastPort6 = zeroIPPort; |
| 14359 | m->PrimaryMAC = zeroEthAddr; |
| 14360 | m->MainCallback = Callback; |
| 14361 | m->MainContext = Context; |
| 14362 | m->rec.r.resrec.RecordType = 0; |
| 14363 | m->rec.r.resrec.AnonInfo = mDNSNULL; |
| 14364 | |
| 14365 | // For debugging: To catch and report locking failures |
| 14366 | m->mDNS_busy = 0; |
| 14367 | m->mDNS_reentrancy = 0; |
| 14368 | m->ShutdownTime = 0; |
| 14369 | m->lock_rrcache = 0; |
| 14370 | m->lock_Questions = 0; |
| 14371 | m->lock_Records = 0; |
| 14372 | |
| 14373 | // Task Scheduling variables |
| 14374 | result = mDNSPlatformTimeInit(); |
| 14375 | if (result != mStatus_NoError) return(result); |
| 14376 | m->timenow_adjust = (mDNSs32)mDNSRandom(0xFFFFFFFF); |
| 14377 | timenow = mDNS_TimeNow_NoLock(m); |
| 14378 | |
| 14379 | m->timenow = 0; // MUST only be set within mDNS_Lock/mDNS_Unlock section |
| 14380 | m->timenow_last = timenow; |
| 14381 | m->NextScheduledEvent = timenow; |
| 14382 | m->SuppressSending = timenow; |
| 14383 | m->NextCacheCheck = timenow + FutureTime; |
| 14384 | m->NextScheduledQuery = timenow + FutureTime; |
| 14385 | m->NextScheduledProbe = timenow + FutureTime; |
| 14386 | m->NextScheduledResponse = timenow + FutureTime; |
| 14387 | m->NextScheduledNATOp = timenow + FutureTime; |
| 14388 | m->NextScheduledSPS = timenow + FutureTime; |
| 14389 | m->NextScheduledKA = timenow + FutureTime; |
| 14390 | m->NextScheduledStopTime = timenow + FutureTime; |
| 14391 | m->NextBLEServiceTime = 0; // zero indicates inactive |
| 14392 | |
| 14393 | #if BONJOUR_ON_DEMAND |
| 14394 | m->NextBonjourDisableTime = 0; // Timer active when non zero. |
| 14395 | m->BonjourEnabled = 0; // Set when Bonjour on Demand is enabled and Bonjour is currently enabled. |
| 14396 | #endif // BONJOUR_ON_DEMAND |
| 14397 | |
| 14398 | m->DelayConflictProcessing = MAX_CONFLICT_PROCESSING_DELAYS; |
| 14399 | m->RandomQueryDelay = 0; |
| 14400 | m->RandomReconfirmDelay = 0; |
| 14401 | m->PktNum = 0; |
| 14402 | m->MPktNum = 0; |
| 14403 | m->LocalRemoveEvents = mDNSfalse; |
| 14404 | m->SleepState = SleepState_Awake; |
| 14405 | m->SleepSeqNum = 0; |
| 14406 | m->SystemWakeOnLANEnabled = mDNSfalse; |
| 14407 | m->AnnounceOwner = NonZeroTime(timenow + 60 * mDNSPlatformOneSecond); |
| 14408 | m->DelaySleep = 0; |
| 14409 | m->SleepLimit = 0; |
| 14410 | |
| 14411 | #if APPLE_OSX_mDNSResponder |
| 14412 | m->UnicastPacketsSent = 0; |
| 14413 | m->MulticastPacketsSent = 0; |
| 14414 | m->RemoteSubnet = 0; |
| 14415 | #endif // APPLE_OSX_mDNSResponder |
| 14416 | |
| 14417 | // These fields only required for mDNS Searcher... |
| 14418 | m->Questions = mDNSNULL; |
| 14419 | m->NewQuestions = mDNSNULL; |
| 14420 | m->CurrentQuestion = mDNSNULL; |
| 14421 | m->LocalOnlyQuestions = mDNSNULL; |
| 14422 | m->NewLocalOnlyQuestions = mDNSNULL; |
| 14423 | m->RestartQuestion = mDNSNULL; |
| 14424 | m->ValidationQuestion = mDNSNULL; |
| 14425 | m->rrcache_size = 0; |
| 14426 | m->rrcache_totalused = 0; |
| 14427 | m->rrcache_active = 0; |
| 14428 | m->rrcache_report = 10; |
| 14429 | m->rrcache_free = mDNSNULL; |
| 14430 | |
| 14431 | for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) |
| 14432 | { |
| 14433 | m->rrcache_hash[slot] = mDNSNULL; |
| 14434 | m->rrcache_nextcheck[slot] = timenow + FutureTime;; |
| 14435 | } |
| 14436 | |
| 14437 | mDNS_GrowCache_internal(m, rrcachestorage, rrcachesize); |
| 14438 | m->rrauth.rrauth_free = mDNSNULL; |
| 14439 | |
| 14440 | for (slot = 0; slot < AUTH_HASH_SLOTS; slot++) |
| 14441 | m->rrauth.rrauth_hash[slot] = mDNSNULL; |
| 14442 | |
| 14443 | // Fields below only required for mDNS Responder... |
| 14444 | m->hostlabel.c[0] = 0; |
| 14445 | m->nicelabel.c[0] = 0; |
| 14446 | m->MulticastHostname.c[0] = 0; |
| 14447 | m->HIHardware.c[0] = 0; |
| 14448 | m->HISoftware.c[0] = 0; |
| 14449 | m->ResourceRecords = mDNSNULL; |
| 14450 | m->DuplicateRecords = mDNSNULL; |
| 14451 | m->NewLocalRecords = mDNSNULL; |
| 14452 | m->NewLocalOnlyRecords = mDNSfalse; |
| 14453 | m->CurrentRecord = mDNSNULL; |
| 14454 | m->HostInterfaces = mDNSNULL; |
| 14455 | m->ProbeFailTime = 0; |
| 14456 | m->NumFailedProbes = 0; |
| 14457 | m->SuppressProbes = 0; |
| 14458 | |
| 14459 | #ifndef UNICAST_DISABLED |
| 14460 | m->NextuDNSEvent = timenow + FutureTime; |
| 14461 | m->NextSRVUpdate = timenow + FutureTime; |
| 14462 | |
| 14463 | m->DNSServers = mDNSNULL; |
| 14464 | |
| 14465 | m->Router = zeroAddr; |
| 14466 | m->AdvertisedV4 = zeroAddr; |
| 14467 | m->AdvertisedV6 = zeroAddr; |
| 14468 | |
| 14469 | m->AuthInfoList = mDNSNULL; |
| 14470 | |
| 14471 | m->ReverseMap.ThisQInterval = -1; |
| 14472 | m->StaticHostname.c[0] = 0; |
| 14473 | m->FQDN.c[0] = 0; |
| 14474 | m->Hostnames = mDNSNULL; |
| 14475 | m->AutoTunnelNAT.clientContext = mDNSNULL; |
| 14476 | |
| 14477 | m->WABBrowseQueriesCount = 0; |
| 14478 | m->WABLBrowseQueriesCount = 0; |
| 14479 | m->WABRegQueriesCount = 0; |
| 14480 | m->AutoTargetServices = 1; |
| 14481 | |
| 14482 | #if BONJOUR_ON_DEMAND |
| 14483 | m->NumAllInterfaceRecords = 0; |
| 14484 | m->NumAllInterfaceQuestions = 0; |
| 14485 | #endif |
| 14486 | // NAT traversal fields |
| 14487 | m->LLQNAT.clientCallback = mDNSNULL; |
| 14488 | m->LLQNAT.clientContext = mDNSNULL; |
| 14489 | m->NATTraversals = mDNSNULL; |
| 14490 | m->CurrentNATTraversal = mDNSNULL; |
| 14491 | m->retryIntervalGetAddr = 0; // delta between time sent and retry |
| 14492 | m->retryGetAddr = timenow + FutureTime; // absolute time when we retry |
| 14493 | m->ExtAddress = zerov4Addr; |
| 14494 | m->PCPNonce[0] = mDNSRandom(-1); |
| 14495 | m->PCPNonce[1] = mDNSRandom(-1); |
| 14496 | m->PCPNonce[2] = mDNSRandom(-1); |
| 14497 | |
| 14498 | m->NATMcastRecvskt = mDNSNULL; |
| 14499 | m->LastNATupseconds = 0; |
| 14500 | m->LastNATReplyLocalTime = timenow; |
| 14501 | m->LastNATMapResultCode = NATErr_None; |
| 14502 | |
| 14503 | m->UPnPInterfaceID = 0; |
| 14504 | m->SSDPSocket = mDNSNULL; |
| 14505 | m->SSDPWANPPPConnection = mDNSfalse; |
| 14506 | m->UPnPRouterPort = zeroIPPort; |
| 14507 | m->UPnPSOAPPort = zeroIPPort; |
| 14508 | m->UPnPRouterURL = mDNSNULL; |
| 14509 | m->UPnPWANPPPConnection = mDNSfalse; |
| 14510 | m->UPnPSOAPURL = mDNSNULL; |
| 14511 | m->UPnPRouterAddressString = mDNSNULL; |
| 14512 | m->UPnPSOAPAddressString = mDNSNULL; |
| 14513 | m->SPSType = 0; |
| 14514 | m->SPSPortability = 0; |
| 14515 | m->SPSMarginalPower = 0; |
| 14516 | m->SPSTotalPower = 0; |
| 14517 | m->SPSFeatureFlags = 0; |
| 14518 | m->SPSState = 0; |
| 14519 | m->SPSProxyListChanged = mDNSNULL; |
| 14520 | m->SPSSocket = mDNSNULL; |
| 14521 | m->SPSBrowseCallback = mDNSNULL; |
| 14522 | m->ProxyRecords = 0; |
| 14523 | |
| 14524 | m->DNSPushServers = mDNSNULL; |
| 14525 | m->DNSPushZones = mDNSNULL; |
| 14526 | #endif |
| 14527 | |
| 14528 | #if APPLE_OSX_mDNSResponder |
| 14529 | m->TunnelClients = mDNSNULL; |
| 14530 | |
| 14531 | #if !NO_WCF |
| 14532 | CHECK_WCF_FUNCTION(WCFConnectionNew) |
| 14533 | { |
| 14534 | m->WCF = WCFConnectionNew(); |
| 14535 | if (!m->WCF) { LogMsg("WCFConnectionNew failed" ); return -1; } |
| 14536 | } |
| 14537 | #endif |
| 14538 | |
| 14539 | #endif |
| 14540 | |
| 14541 | return(result); |
| 14542 | } |
| 14543 | |
| 14544 | mDNSexport mStatus mDNS_Init(mDNS *const m, mDNS_PlatformSupport *const p, |
| 14545 | CacheEntity *rrcachestorage, mDNSu32 rrcachesize, |
| 14546 | mDNSBool AdvertiseLocalAddresses, mDNSCallback *Callback, void *Context) |
| 14547 | { |
| 14548 | mStatus result = mDNS_InitStorage(m, p, rrcachestorage, rrcachesize, AdvertiseLocalAddresses, Callback, Context); |
| 14549 | if (result != mStatus_NoError) |
| 14550 | return(result); |
| 14551 | |
| 14552 | result = mDNSPlatformInit(m); |
| 14553 | |
| 14554 | #ifndef UNICAST_DISABLED |
| 14555 | // It's better to do this *after* the platform layer has set up the |
| 14556 | // interface list and security credentials |
| 14557 | uDNS_SetupDNSConfig(m); // Get initial DNS configuration |
| 14558 | #endif |
| 14559 | |
| 14560 | return(result); |
| 14561 | } |
| 14562 | |
| 14563 | mDNSexport void mDNS_ConfigChanged(mDNS *const m) |
| 14564 | { |
| 14565 | if (m->SPSState == 1) |
| 14566 | { |
| 14567 | domainlabel name, newname; |
| 14568 | #ifndef SPC_DISABLED |
| 14569 | domainname type, domain; |
| 14570 | DeconstructServiceName(m->SPSRecords.RR_SRV.resrec.name, &name, &type, &domain); |
| 14571 | #endif // SPC_DISABLED |
| 14572 | ConstructSleepProxyServerName(m, &newname); |
| 14573 | if (!SameDomainLabelCS(name.c, newname.c)) |
| 14574 | { |
| 14575 | LogSPS("Renaming SPS from “%#s” to “%#s”" , name.c, newname.c); |
| 14576 | // When SleepProxyServerCallback gets the mStatus_MemFree message, |
| 14577 | // it will reregister the service under the new name |
| 14578 | m->SPSState = 2; |
| 14579 | #ifndef SPC_DISABLED |
| 14580 | mDNS_DeregisterService_drt(m, &m->SPSRecords, mDNS_Dereg_rapid); |
| 14581 | #endif // SPC_DISABLED |
| 14582 | } |
| 14583 | } |
| 14584 | |
| 14585 | if (m->MainCallback) |
| 14586 | m->MainCallback(m, mStatus_ConfigChanged); |
| 14587 | } |
| 14588 | |
| 14589 | mDNSlocal void DynDNSHostNameCallback(mDNS *const m, AuthRecord *const rr, mStatus result) |
| 14590 | { |
| 14591 | (void)m; // unused |
| 14592 | debugf("NameStatusCallback: result %d for registration of name %##s" , result, rr->resrec.name->c); |
| 14593 | mDNSPlatformDynDNSHostNameStatusChanged(rr->resrec.name, result); |
| 14594 | } |
| 14595 | |
| 14596 | mDNSlocal void PurgeOrReconfirmCacheRecord(mDNS *const m, CacheRecord *cr, const DNSServer * const ptr, mDNSBool lameduck) |
| 14597 | { |
| 14598 | mDNSBool purge = cr->resrec.RecordType == kDNSRecordTypePacketNegative || |
| 14599 | cr->resrec.rrtype == kDNSType_A || |
| 14600 | cr->resrec.rrtype == kDNSType_AAAA || |
| 14601 | cr->resrec.rrtype == kDNSType_SRV || |
| 14602 | cr->resrec.rrtype == kDNSType_CNAME; |
| 14603 | |
| 14604 | (void) lameduck; |
| 14605 | (void) ptr; |
| 14606 | debugf("PurgeOrReconfirmCacheRecord: %s cache record due to %s server %p %#a:%d (%##s): %s" , |
| 14607 | purge ? "purging" : "reconfirming" , |
| 14608 | lameduck ? "lame duck" : "new" , |
| 14609 | ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c, CRDisplayString(m, cr)); |
| 14610 | |
| 14611 | if (purge) |
| 14612 | { |
| 14613 | LogInfo("PurgeorReconfirmCacheRecord: Purging Resourcerecord %s, RecordType %x" , CRDisplayString(m, cr), cr->resrec.RecordType); |
| 14614 | mDNS_PurgeCacheResourceRecord(m, cr); |
| 14615 | } |
| 14616 | else |
| 14617 | { |
| 14618 | LogInfo("PurgeorReconfirmCacheRecord: Reconfirming Resourcerecord %s, RecordType %x" , CRDisplayString(m, cr), cr->resrec.RecordType); |
| 14619 | mDNS_Reconfirm_internal(m, cr, kDefaultReconfirmTimeForNoAnswer); |
| 14620 | } |
| 14621 | } |
| 14622 | |
| 14623 | mDNSlocal void mDNS_PurgeForQuestion(mDNS *const m, DNSQuestion *q) |
| 14624 | { |
| 14625 | CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 14626 | CacheRecord *rp; |
| 14627 | mDNSu8 validatingResponse = 0; |
| 14628 | |
| 14629 | // For DNSSEC questions, purge the corresponding RRSIGs also. |
| 14630 | if (DNSSECQuestion(q)) |
| 14631 | { |
| 14632 | validatingResponse = q->ValidatingResponse; |
| 14633 | q->ValidatingResponse = mDNStrue; |
| 14634 | } |
| 14635 | for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next) |
| 14636 | { |
| 14637 | if (SameNameRecordAnswersQuestion(&rp->resrec, q)) |
| 14638 | { |
| 14639 | LogInfo("mDNS_PurgeForQuestion: Flushing %s" , CRDisplayString(m, rp)); |
| 14640 | mDNS_PurgeCacheResourceRecord(m, rp); |
| 14641 | } |
| 14642 | } |
| 14643 | if (DNSSECQuestion(q)) |
| 14644 | { |
| 14645 | q->ValidatingResponse = validatingResponse; |
| 14646 | } |
| 14647 | } |
| 14648 | |
| 14649 | // For DNSSEC question, we need the DNSSEC records also. If the cache does not |
| 14650 | // have the DNSSEC records, we need to re-issue the question with EDNS0/DO bit set. |
| 14651 | // Just re-issuing the question for RRSIGs does not work in practice as the response |
| 14652 | // may not contain the RRSIGs whose typeCovered field matches the question's qtype. |
| 14653 | // |
| 14654 | // For negative responses, we need the NSECs to prove the non-existence. If we don't |
| 14655 | // have the cached NSECs, purge them. For positive responses, if we don't have the |
| 14656 | // RRSIGs and if we have not already issued the question with EDNS0/DO bit set, purge |
| 14657 | // them. |
| 14658 | mDNSlocal void CheckForDNSSECRecords(mDNS *const m, DNSQuestion *q) |
| 14659 | { |
| 14660 | CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 14661 | CacheRecord *rp; |
| 14662 | |
| 14663 | for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next) |
| 14664 | { |
| 14665 | if (SameNameRecordAnswersQuestion(&rp->resrec, q)) |
| 14666 | { |
| 14667 | if (rp->resrec.RecordType != kDNSRecordTypePacketNegative || !rp->nsec) |
| 14668 | { |
| 14669 | if (!rp->CRDNSSECQuestion) |
| 14670 | { |
| 14671 | LogInfo("CheckForDNSSECRecords: Flushing %s" , CRDisplayString(m, rp)); |
| 14672 | mDNS_PurgeCacheResourceRecord(m, rp); |
| 14673 | } |
| 14674 | } |
| 14675 | } |
| 14676 | } |
| 14677 | } |
| 14678 | |
| 14679 | // Check for a positive unicast response to the question but with qtype |
| 14680 | mDNSexport mDNSBool mDNS_CheckForCacheRecord(mDNS *const m, DNSQuestion *q, mDNSu16 qtype) |
| 14681 | { |
| 14682 | DNSQuestion question; |
| 14683 | CacheGroup *const cg = CacheGroupForName(m, q->qnamehash, &q->qname); |
| 14684 | CacheRecord *rp; |
| 14685 | |
| 14686 | // Create an identical question but with qtype |
| 14687 | mDNS_SetupQuestion(&question, q->InterfaceID, &q->qname, qtype, mDNSNULL, mDNSNULL); |
| 14688 | question.qDNSServer = q->qDNSServer; |
| 14689 | |
| 14690 | for (rp = cg ? cg->members : mDNSNULL; rp; rp = rp->next) |
| 14691 | { |
| 14692 | if (!rp->resrec.InterfaceID && rp->resrec.RecordType != kDNSRecordTypePacketNegative && |
| 14693 | SameNameRecordAnswersQuestion(&rp->resrec, &question)) |
| 14694 | { |
| 14695 | LogInfo("mDNS_CheckForCacheRecord: Found %s" , CRDisplayString(m, rp)); |
| 14696 | return mDNStrue; |
| 14697 | } |
| 14698 | } |
| 14699 | return mDNSfalse; |
| 14700 | } |
| 14701 | |
| 14702 | mDNSexport void DNSServerChangeForQuestion(mDNS *const m, DNSQuestion *q, DNSServer *new) |
| 14703 | { |
| 14704 | DNSQuestion *qptr; |
| 14705 | |
| 14706 | (void) m; |
| 14707 | |
| 14708 | if (q->DuplicateOf) |
| 14709 | LogMsg("DNSServerChangeForQuestion: ERROR: Called for duplicate question %##s" , q->qname.c); |
| 14710 | |
| 14711 | // Make sure all the duplicate questions point to the same DNSServer so that delivery |
| 14712 | // of events for all of them are consistent. Duplicates for a question are always inserted |
| 14713 | // after in the list. |
| 14714 | q->qDNSServer = new; |
| 14715 | for (qptr = q->next ; qptr; qptr = qptr->next) |
| 14716 | { |
| 14717 | if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = new; } |
| 14718 | } |
| 14719 | } |
| 14720 | |
| 14721 | mDNSlocal void SetConfigState(mDNS *const m, mDNSBool delete) |
| 14722 | { |
| 14723 | McastResolver *mr; |
| 14724 | DNSServer *ptr; |
| 14725 | |
| 14726 | if (delete) |
| 14727 | { |
| 14728 | for (ptr = m->DNSServers; ptr; ptr = ptr->next) |
| 14729 | { |
| 14730 | ptr->penaltyTime = 0; |
| 14731 | NumUnicastDNSServers--; |
| 14732 | ptr->flags |= DNSServer_FlagDelete; |
| 14733 | #if APPLE_OSX_mDNSResponder |
| 14734 | if (ptr->flags & DNSServer_FlagUnreachable) |
| 14735 | NumUnreachableDNSServers--; |
| 14736 | #endif |
| 14737 | } |
| 14738 | // We handle the mcast resolvers here itself as mDNSPlatformSetDNSConfig looks at |
| 14739 | // mcast resolvers. Today we get both mcast and ucast configuration using the same |
| 14740 | // API |
| 14741 | for (mr = m->McastResolvers; mr; mr = mr->next) |
| 14742 | mr->flags |= McastResolver_FlagDelete; |
| 14743 | } |
| 14744 | else |
| 14745 | { |
| 14746 | for (ptr = m->DNSServers; ptr; ptr = ptr->next) |
| 14747 | { |
| 14748 | ptr->penaltyTime = 0; |
| 14749 | NumUnicastDNSServers++; |
| 14750 | ptr->flags &= ~DNSServer_FlagDelete; |
| 14751 | #if APPLE_OSX_mDNSResponder |
| 14752 | if (ptr->flags & DNSServer_FlagUnreachable) |
| 14753 | NumUnreachableDNSServers++; |
| 14754 | #endif |
| 14755 | } |
| 14756 | for (mr = m->McastResolvers; mr; mr = mr->next) |
| 14757 | mr->flags &= ~McastResolver_FlagDelete; |
| 14758 | } |
| 14759 | } |
| 14760 | |
| 14761 | mDNSlocal void SetDynDNSHostNameIfChanged(mDNS *const m, domainname *const fqdn) |
| 14762 | { |
| 14763 | // Did our FQDN change? |
| 14764 | if (!SameDomainName(fqdn, &m->FQDN)) |
| 14765 | { |
| 14766 | if (m->FQDN.c[0]) mDNS_RemoveDynDNSHostName(m, &m->FQDN); |
| 14767 | |
| 14768 | AssignDomainName(&m->FQDN, fqdn); |
| 14769 | |
| 14770 | if (m->FQDN.c[0]) |
| 14771 | { |
| 14772 | mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); |
| 14773 | mDNS_AddDynDNSHostName(m, &m->FQDN, DynDNSHostNameCallback, mDNSNULL); |
| 14774 | } |
| 14775 | } |
| 14776 | } |
| 14777 | |
| 14778 | mDNSexport mStatus uDNS_SetupDNSConfig(mDNS *const m) |
| 14779 | { |
| 14780 | mDNSu32 slot; |
| 14781 | CacheGroup *cg; |
| 14782 | CacheRecord *cr; |
| 14783 | mDNSBool Restart = mDNSfalse; |
| 14784 | mDNSAddr v4, v6, r; |
| 14785 | domainname fqdn; |
| 14786 | DNSServer *ptr, **p = &m->DNSServers; |
| 14787 | const DNSServer *oldServers = m->DNSServers; |
| 14788 | DNSQuestion *q; |
| 14789 | McastResolver *mr, **mres = &m->McastResolvers; |
| 14790 | |
| 14791 | debugf("uDNS_SetupDNSConfig: entry" ); |
| 14792 | |
| 14793 | // Let the platform layer get the current DNS information and setup the WAB queries if needed. |
| 14794 | uDNS_SetupWABQueries(m); |
| 14795 | |
| 14796 | mDNS_Lock(m); |
| 14797 | |
| 14798 | // We need to first mark all the entries to be deleted. If the configuration changed, then |
| 14799 | // the entries would be undeleted appropriately. Otherwise, we need to clear them. |
| 14800 | // |
| 14801 | // Note: The last argument to mDNSPlatformSetDNSConfig is "mDNStrue" which means ack the |
| 14802 | // configuration. We already processed search domains in uDNS_SetupWABQueries above and |
| 14803 | // hence we are ready to ack the configuration as this is the last call to mDNSPlatformSetConfig |
| 14804 | // for the dns configuration change notification. |
| 14805 | SetConfigState(m, mDNStrue); |
| 14806 | if (!mDNSPlatformSetDNSConfig(mDNStrue, mDNSfalse, &fqdn, mDNSNULL, mDNSNULL, mDNStrue)) |
| 14807 | { |
| 14808 | SetDynDNSHostNameIfChanged(m, &fqdn); |
| 14809 | SetConfigState(m, mDNSfalse); |
| 14810 | mDNS_Unlock(m); |
| 14811 | LogInfo("uDNS_SetupDNSConfig: No configuration change" ); |
| 14812 | return mStatus_NoError; |
| 14813 | } |
| 14814 | |
| 14815 | // For now, we just delete the mcast resolvers. We don't deal with cache or |
| 14816 | // questions here. Neither question nor cache point to mcast resolvers. Questions |
| 14817 | // do inherit the timeout values from mcast resolvers. But we don't bother |
| 14818 | // affecting them as they never change. |
| 14819 | while (*mres) |
| 14820 | { |
| 14821 | if (((*mres)->flags & McastResolver_FlagDelete) != 0) |
| 14822 | { |
| 14823 | mr = *mres; |
| 14824 | *mres = (*mres)->next; |
| 14825 | debugf("uDNS_SetupDNSConfig: Deleting mcast resolver %##s" , mr, mr->domain.c); |
| 14826 | mDNSPlatformMemFree(mr); |
| 14827 | } |
| 14828 | else |
| 14829 | { |
| 14830 | (*mres)->flags &= ~McastResolver_FlagNew; |
| 14831 | mres = &(*mres)->next; |
| 14832 | } |
| 14833 | } |
| 14834 | |
| 14835 | // Update our qDNSServer pointers before we go and free the DNSServer object memory |
| 14836 | // |
| 14837 | // All non-scoped resolvers share the same resGroupID. At no point in time a cache entry using DNSServer |
| 14838 | // from scoped resolver will be used to answer non-scoped questions and vice versa, as scoped and non-scoped |
| 14839 | // resolvers don't share the same resGroupID. A few examples to describe the interaction with how we pick |
| 14840 | // DNSServers and flush the cache. |
| 14841 | // |
| 14842 | // - A non-scoped question picks DNSServer X, creates a cache entry with X. If a new resolver gets added later that |
| 14843 | // is a better match, we pick the new DNSServer for the question and activate the unicast query. We may or may not |
| 14844 | // flush the cache (See PurgeOrReconfirmCacheRecord). In either case, we don't change the cache record's DNSServer |
| 14845 | // pointer immediately (qDNSServer and rDNSServer may be different but still share the same resGroupID). If we don't |
| 14846 | // flush the cache immediately, the record's rDNSServer pointer will be updated (in mDNSCoreReceiveResponse) |
| 14847 | // later when we get the response. If we purge the cache, we still deliver a RMV when it is purged even though |
| 14848 | // we don't update the cache record's DNSServer pointer to match the question's DNSSever, as they both point to |
| 14849 | // the same resGroupID. |
| 14850 | // |
| 14851 | // Note: If the new DNSServer comes back with a different response than what we have in the cache, we will deliver a RMV |
| 14852 | // of the old followed by ADD of the new records. |
| 14853 | // |
| 14854 | // - A non-scoped question picks DNSServer X, creates a cache entry with X. If the resolver gets removed later, we will |
| 14855 | // pick a new DNSServer for the question which may or may not be NULL and set the cache record's pointer to the same |
| 14856 | // as in question's qDNSServer if the cache record is not flushed. If there is no active question, it will be set to NULL. |
| 14857 | // |
| 14858 | // - Two questions scoped and non-scoped for the same name will pick two different DNSServer and will end up creating separate |
| 14859 | // cache records and as the resGroupID is different, you can't use the cache record from the scoped DNSServer to answer the |
| 14860 | // non-scoped question and vice versa. |
| 14861 | // |
| 14862 | #if USE_DNS64 |
| 14863 | DNS64RestartQuestions(m); |
| 14864 | #endif |
| 14865 | for (q = m->Questions; q; q=q->next) |
| 14866 | { |
| 14867 | if (!mDNSOpaque16IsZero(q->TargetQID)) |
| 14868 | { |
| 14869 | DNSServer *s, *t; |
| 14870 | DNSQuestion *qptr; |
| 14871 | if (q->DuplicateOf) continue; |
| 14872 | SetValidDNSServers(m, q); |
| 14873 | q->triedAllServersOnce = 0; |
| 14874 | s = GetServerForQuestion(m, q); |
| 14875 | t = q->qDNSServer; |
| 14876 | if (t != s) |
| 14877 | { |
| 14878 | mDNSBool old, new; |
| 14879 | // If DNS Server for this question has changed, reactivate it |
| 14880 | LogInfo("uDNS_SetupDNSConfig: Updating DNS Server from %#a:%d (%##s) to %#a:%d (%##s) for question %##s (%s) (scope:%p)" , |
| 14881 | t ? &t->addr : mDNSNULL, mDNSVal16(t ? t->port : zeroIPPort), t ? t->domain.c : (mDNSu8*)"" , |
| 14882 | s ? &s->addr : mDNSNULL, mDNSVal16(s ? s->port : zeroIPPort), s ? s->domain.c : (mDNSu8*)"" , |
| 14883 | q->qname.c, DNSTypeName(q->qtype), q->InterfaceID); |
| 14884 | |
| 14885 | old = q->SuppressQuery; |
| 14886 | new = ShouldSuppressUnicastQuery(m, q, s); |
| 14887 | if (old != new) |
| 14888 | { |
| 14889 | // Changing the DNS server affected the SuppressQuery status. We need to |
| 14890 | // deliver RMVs for the previous ADDs (if any) before switching to the new |
| 14891 | // DNSServer. To keep it simple, we walk all the questions and mark them |
| 14892 | // to be restarted and then handle all of them at once. |
| 14893 | q->Restart = 1; |
| 14894 | q->SuppressQuery = new; |
| 14895 | for (qptr = q->next ; qptr; qptr = qptr->next) |
| 14896 | { |
| 14897 | if (qptr->DuplicateOf == q) |
| 14898 | qptr->Restart = 1; |
| 14899 | } |
| 14900 | Restart = mDNStrue; |
| 14901 | } |
| 14902 | else |
| 14903 | { |
| 14904 | DNSServerChangeForQuestion(m, q, s); |
| 14905 | q->unansweredQueries = 0; |
| 14906 | |
| 14907 | // If we had sent a query out to DNSServer "t" and we are changing to "s", we |
| 14908 | // need to ignore the responses coming back from "t" as the DNS configuration |
| 14909 | // has changed e.g., when a new interface is coming up and that becomes the primary |
| 14910 | // interface, we switch to the DNS servers configured for the primary interface. In |
| 14911 | // this case, we should not accept responses associated with the previous interface as |
| 14912 | // the "name" could resolve differently on this new primary interface. Hence, discard |
| 14913 | // in-flight responses. |
| 14914 | q->TargetQID = mDNS_NewMessageID(m); |
| 14915 | |
| 14916 | if (!QuerySuppressed(q)) |
| 14917 | { |
| 14918 | debugf("uDNS_SetupDNSConfig: Activating query %p %##s (%s)" , q, q->qname.c, DNSTypeName(q->qtype)); |
| 14919 | ActivateUnicastQuery(m, q, mDNStrue); |
| 14920 | // ActivateUnicastQuery is called for duplicate questions also as it does something |
| 14921 | // special for AutoTunnel questions |
| 14922 | for (qptr = q->next ; qptr; qptr = qptr->next) |
| 14923 | { |
| 14924 | if (qptr->DuplicateOf == q) ActivateUnicastQuery(m, qptr, mDNStrue); |
| 14925 | } |
| 14926 | } |
| 14927 | } |
| 14928 | } |
| 14929 | else |
| 14930 | { |
| 14931 | debugf("uDNS_SetupDNSConfig: Not Updating DNS server question %p %##s (%s) DNS server %#a:%d %p %d" , |
| 14932 | q, q->qname.c, DNSTypeName(q->qtype), t ? &t->addr : mDNSNULL, mDNSVal16(t ? t->port : zeroIPPort), q->DuplicateOf, q->SuppressUnusable); |
| 14933 | for (qptr = q->next ; qptr; qptr = qptr->next) |
| 14934 | if (qptr->DuplicateOf == q) { qptr->validDNSServers = q->validDNSServers; qptr->qDNSServer = q->qDNSServer; } |
| 14935 | } |
| 14936 | } |
| 14937 | } |
| 14938 | if (Restart) |
| 14939 | RestartUnicastQuestions(m); |
| 14940 | |
| 14941 | FORALL_CACHERECORDS(slot, cg, cr) |
| 14942 | { |
| 14943 | if (cr->resrec.InterfaceID) |
| 14944 | continue; |
| 14945 | |
| 14946 | // We already walked the questions and restarted/reactivated them if the dns server |
| 14947 | // change affected the question. That should take care of updating the cache. But |
| 14948 | // what if there is no active question at this point when the DNS server change |
| 14949 | // happened ? There could be old cache entries lying around and if we don't flush |
| 14950 | // them, a new question after the DNS server change could pick up these stale |
| 14951 | // entries and get a wrong answer. |
| 14952 | // |
| 14953 | // For cache entries that have active questions we might have skipped rescheduling |
| 14954 | // the questions if they were suppressed (see above). To keep it simple, we walk |
| 14955 | // all the cache entries to make sure that there are no stale entries. We use the |
| 14956 | // active question's InterfaceID/ServiceID for looking up the right DNS server. |
| 14957 | // Note that the unscoped value for ServiceID is -1. |
| 14958 | // |
| 14959 | // Note: If GetServerForName returns NULL, it could either mean that there are no |
| 14960 | // DNS servers or no matching DNS servers for this question. In either case, |
| 14961 | // the cache should get purged below when we process deleted DNS servers. |
| 14962 | |
| 14963 | ptr = GetServerForName(m, cr->resrec.name, |
| 14964 | (cr->CRActiveQuestion ? cr->CRActiveQuestion->InterfaceID : mDNSNULL), |
| 14965 | (cr->CRActiveQuestion ? cr->CRActiveQuestion->ServiceID : -1)); |
| 14966 | |
| 14967 | // Purge or Reconfirm if this cache entry would use the new DNS server |
| 14968 | if (ptr && (ptr != cr->resrec.rDNSServer)) |
| 14969 | { |
| 14970 | // As the DNSServers for this cache record is not the same anymore, we don't |
| 14971 | // want any new questions to pick this old value. If there is no active question, |
| 14972 | // we can't possibly re-confirm, so purge in that case. If it is a DNSSEC question, |
| 14973 | // purge the cache as the DNSSEC capabilities of the DNS server may have changed. |
| 14974 | |
| 14975 | if (cr->CRActiveQuestion == mDNSNULL || DNSSECQuestion(cr->CRActiveQuestion)) |
| 14976 | { |
| 14977 | LogInfo("uDNS_SetupDNSConfig: Purging Resourcerecord %s, New DNS server %#a , Old DNS server %#a" , CRDisplayString(m, cr), |
| 14978 | &ptr->addr, (cr->resrec.rDNSServer != mDNSNULL ? &cr->resrec.rDNSServer->addr : mDNSNULL)); |
| 14979 | mDNS_PurgeCacheResourceRecord(m, cr); |
| 14980 | } |
| 14981 | else |
| 14982 | { |
| 14983 | LogInfo("uDNS_SetupDNSConfig: Purging/Reconfirming Resourcerecord %s, New DNS server %#a, Old DNS server %#a" , CRDisplayString(m, cr), |
| 14984 | &ptr->addr, (cr->resrec.rDNSServer != mDNSNULL ? &cr->resrec.rDNSServer->addr : mDNSNULL)); |
| 14985 | PurgeOrReconfirmCacheRecord(m, cr, ptr, mDNSfalse); |
| 14986 | } |
| 14987 | } |
| 14988 | |
| 14989 | // If a cache record's DNSServer pointer is NULL, but its active question got a DNSServer in this DNS configuration |
| 14990 | // update, then use its DNSServer. This way, the active question and its duplicates don't miss out on RMV events. |
| 14991 | if (!cr->resrec.rDNSServer && cr->CRActiveQuestion && cr->CRActiveQuestion->qDNSServer) |
| 14992 | { |
| 14993 | cr->resrec.rDNSServer = cr->CRActiveQuestion->qDNSServer; |
| 14994 | LogInfo("uDNS_SetupDNSConfig: Using active question's DNS server %#a for cache record %s" , &cr->resrec.rDNSServer->addr, CRDisplayString(m, cr)); |
| 14995 | } |
| 14996 | } |
| 14997 | |
| 14998 | while (*p) |
| 14999 | { |
| 15000 | if (((*p)->flags & DNSServer_FlagDelete) != 0) |
| 15001 | { |
| 15002 | // Scan our cache, looking for uDNS records that we would have queried this server for. |
| 15003 | // We reconfirm any records that match, because in this world of split DNS, firewalls, etc. |
| 15004 | // different DNS servers can give different answers to the same question. |
| 15005 | ptr = *p; |
| 15006 | FORALL_CACHERECORDS(slot, cg, cr) |
| 15007 | { |
| 15008 | if (cr->resrec.InterfaceID) continue; |
| 15009 | if (cr->resrec.rDNSServer == ptr) |
| 15010 | { |
| 15011 | // If we don't have an active question for this cache record, neither Purge can |
| 15012 | // generate RMV events nor Reconfirm can send queries out. Just set the DNSServer |
| 15013 | // pointer on the record NULL so that we don't point to freed memory (We might dereference |
| 15014 | // DNSServer pointers from resource record for logging purposes). |
| 15015 | // |
| 15016 | // If there is an active question, point to its DNSServer as long as it does not point to the |
| 15017 | // freed one. We already went through the questions above and made them point at either the |
| 15018 | // new server or NULL if there is no server. |
| 15019 | |
| 15020 | if (cr->CRActiveQuestion) |
| 15021 | { |
| 15022 | DNSQuestion *qptr = cr->CRActiveQuestion; |
| 15023 | |
| 15024 | if (qptr->qDNSServer == ptr) |
| 15025 | { |
| 15026 | LogMsg("uDNS_SetupDNSConfig: ERROR!! Cache Record %s Active question %##s (%s) (scope:%p) pointing to DNSServer Address %#a" |
| 15027 | " to be freed" , CRDisplayString(m, cr), qptr->qname.c, DNSTypeName(qptr->qtype), qptr->InterfaceID, &ptr->addr); |
| 15028 | qptr->validDNSServers = zeroOpaque128; |
| 15029 | qptr->qDNSServer = mDNSNULL; |
| 15030 | cr->resrec.rDNSServer = mDNSNULL; |
| 15031 | } |
| 15032 | else |
| 15033 | { |
| 15034 | LogInfo("uDNS_SetupDNSConfig: Cache Record %s, Active question %##s (%s) (scope:%p), pointing to DNSServer %#a (to be deleted)," |
| 15035 | " resetting to question's DNSServer Address %#a" , CRDisplayString(m, cr), qptr->qname.c, DNSTypeName(qptr->qtype), |
| 15036 | qptr->InterfaceID, &ptr->addr, (qptr->qDNSServer) ? &qptr->qDNSServer->addr : mDNSNULL); |
| 15037 | cr->resrec.rDNSServer = qptr->qDNSServer; |
| 15038 | } |
| 15039 | } |
| 15040 | else |
| 15041 | { |
| 15042 | LogInfo("uDNS_SetupDNSConfig: Cache Record %##s has no Active question, Record's DNSServer Address %#a, Server to be deleted %#a" , |
| 15043 | cr->resrec.name, &cr->resrec.rDNSServer->addr, &ptr->addr); |
| 15044 | cr->resrec.rDNSServer = mDNSNULL; |
| 15045 | } |
| 15046 | |
| 15047 | PurgeOrReconfirmCacheRecord(m, cr, ptr, mDNStrue); |
| 15048 | } |
| 15049 | } |
| 15050 | *p = (*p)->next; |
| 15051 | LogInfo("uDNS_SetupDNSConfig: Deleting server %p %#a:%d (%##s) %d" , ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c, NumUnicastDNSServers); |
| 15052 | mDNSPlatformMemFree(ptr); |
| 15053 | } |
| 15054 | else |
| 15055 | { |
| 15056 | (*p)->flags &= ~DNSServer_FlagNew; |
| 15057 | p = &(*p)->next; |
| 15058 | } |
| 15059 | } |
| 15060 | |
| 15061 | // If we now have no DNS servers at all and we used to have some, then immediately purge all unicast cache records (including for LLQs). |
| 15062 | // This is important for giving prompt remove events when the user disconnects the Ethernet cable or turns off wireless. |
| 15063 | // Otherwise, stale data lingers for 5-10 seconds, which is not the user-experience people expect from Bonjour. |
| 15064 | // Similarly, if we now have some DNS servers and we used to have none, we want to purge any fake negative results we may have generated. |
| 15065 | if ((m->DNSServers != mDNSNULL) != (oldServers != mDNSNULL)) |
| 15066 | { |
| 15067 | int count = 0; |
| 15068 | FORALL_CACHERECORDS(slot, cg, cr) |
| 15069 | { |
| 15070 | if (!cr->resrec.InterfaceID) |
| 15071 | { |
| 15072 | mDNS_PurgeCacheResourceRecord(m, cr); |
| 15073 | count++; |
| 15074 | } |
| 15075 | } |
| 15076 | LogInfo("uDNS_SetupDNSConfig: %s available; purged %d unicast DNS records from cache" , |
| 15077 | m->DNSServers ? "DNS server became" : "No DNS servers" , count); |
| 15078 | |
| 15079 | // Force anything that needs to get zone data to get that information again |
| 15080 | RestartRecordGetZoneData(m); |
| 15081 | } |
| 15082 | |
| 15083 | SetDynDNSHostNameIfChanged(m, &fqdn); |
| 15084 | |
| 15085 | mDNS_Unlock(m); |
| 15086 | |
| 15087 | // handle router and primary interface changes |
| 15088 | v4 = v6 = r = zeroAddr; |
| 15089 | v4.type = r.type = mDNSAddrType_IPv4; |
| 15090 | |
| 15091 | if (mDNSPlatformGetPrimaryInterface(&v4, &v6, &r) == mStatus_NoError && !mDNSv4AddressIsLinkLocal(&v4.ip.v4)) |
| 15092 | { |
| 15093 | mDNS_SetPrimaryInterfaceInfo(m, |
| 15094 | !mDNSIPv4AddressIsZero(v4.ip.v4) ? &v4 : mDNSNULL, |
| 15095 | !mDNSIPv6AddressIsZero(v6.ip.v6) ? &v6 : mDNSNULL, |
| 15096 | !mDNSIPv4AddressIsZero(r.ip.v4) ? &r : mDNSNULL); |
| 15097 | } |
| 15098 | else |
| 15099 | { |
| 15100 | mDNS_SetPrimaryInterfaceInfo(m, mDNSNULL, mDNSNULL, mDNSNULL); |
| 15101 | if (m->FQDN.c[0]) mDNSPlatformDynDNSHostNameStatusChanged(&m->FQDN, 1); // Set status to 1 to indicate temporary failure |
| 15102 | } |
| 15103 | |
| 15104 | debugf("uDNS_SetupDNSConfig: number of unicast DNS servers %d" , NumUnicastDNSServers); |
| 15105 | return mStatus_NoError; |
| 15106 | } |
| 15107 | |
| 15108 | mDNSexport void mDNSCoreInitComplete(mDNS *const m, mStatus result) |
| 15109 | { |
| 15110 | m->mDNSPlatformStatus = result; |
| 15111 | if (m->MainCallback) |
| 15112 | { |
| 15113 | mDNS_Lock(m); |
| 15114 | mDNS_DropLockBeforeCallback(); // Allow client to legally make mDNS API calls from the callback |
| 15115 | m->MainCallback(m, mStatus_NoError); |
| 15116 | mDNS_ReclaimLockAfterCallback(); // Decrement mDNS_reentrancy to block mDNS API calls again |
| 15117 | mDNS_Unlock(m); |
| 15118 | } |
| 15119 | } |
| 15120 | |
| 15121 | mDNSlocal void DeregLoop(mDNS *const m, AuthRecord *const start) |
| 15122 | { |
| 15123 | m->CurrentRecord = start; |
| 15124 | while (m->CurrentRecord) |
| 15125 | { |
| 15126 | AuthRecord *rr = m->CurrentRecord; |
| 15127 | LogInfo("DeregLoop: %s deregistration for %p %02X %s" , |
| 15128 | (rr->resrec.RecordType != kDNSRecordTypeDeregistering) ? "Initiating " : "Accelerating" , |
| 15129 | rr, rr->resrec.RecordType, ARDisplayString(m, rr)); |
| 15130 | if (rr->resrec.RecordType != kDNSRecordTypeDeregistering) |
| 15131 | mDNS_Deregister_internal(m, rr, mDNS_Dereg_rapid); |
| 15132 | else if (rr->AnnounceCount > 1) |
| 15133 | { |
| 15134 | rr->AnnounceCount = 1; |
| 15135 | rr->LastAPTime = m->timenow - rr->ThisAPInterval; |
| 15136 | } |
| 15137 | // Mustn't advance m->CurrentRecord until *after* mDNS_Deregister_internal, because |
| 15138 | // new records could have been added to the end of the list as a result of that call. |
| 15139 | if (m->CurrentRecord == rr) // If m->CurrentRecord was not advanced for us, do it now |
| 15140 | m->CurrentRecord = rr->next; |
| 15141 | } |
| 15142 | } |
| 15143 | |
| 15144 | mDNSexport void mDNS_StartExit(mDNS *const m) |
| 15145 | { |
| 15146 | AuthRecord *rr; |
| 15147 | |
| 15148 | mDNS_Lock(m); |
| 15149 | |
| 15150 | LogInfo("mDNS_StartExit" ); |
| 15151 | m->ShutdownTime = NonZeroTime(m->timenow + mDNSPlatformOneSecond * 5); |
| 15152 | |
| 15153 | mDNSCoreBeSleepProxyServer_internal(m, 0, 0, 0, 0, 0); |
| 15154 | |
| 15155 | #if APPLE_OSX_mDNSResponder |
| 15156 | #if !NO_WCF |
| 15157 | CHECK_WCF_FUNCTION(WCFConnectionDealloc) |
| 15158 | { |
| 15159 | if (m->WCF) WCFConnectionDealloc((WCFConnection *)m->WCF); |
| 15160 | } |
| 15161 | #endif |
| 15162 | #endif |
| 15163 | |
| 15164 | #ifndef UNICAST_DISABLED |
| 15165 | { |
| 15166 | SearchListElem *s; |
| 15167 | SuspendLLQs(m); |
| 15168 | // Don't need to do SleepRecordRegistrations() here |
| 15169 | // because we deregister all records and services later in this routine |
| 15170 | while (m->Hostnames) mDNS_RemoveDynDNSHostName(m, &m->Hostnames->fqdn); |
| 15171 | |
| 15172 | // For each member of our SearchList, deregister any records it may have created, and cut them from the list. |
| 15173 | // Otherwise they'll be forcibly deregistered for us (without being cut them from the appropriate list) |
| 15174 | // and we may crash because the list still contains dangling pointers. |
| 15175 | for (s = SearchList; s; s = s->next) |
| 15176 | while (s->AuthRecs) |
| 15177 | { |
| 15178 | ARListElem *dereg = s->AuthRecs; |
| 15179 | s->AuthRecs = s->AuthRecs->next; |
| 15180 | mDNS_Deregister_internal(m, &dereg->ar, mDNS_Dereg_normal); // Memory will be freed in the FreeARElemCallback |
| 15181 | } |
| 15182 | } |
| 15183 | #endif |
| 15184 | |
| 15185 | DeadvertiseAllInterfaceRecords(m); |
| 15186 | |
| 15187 | // Shut down all our active NAT Traversals |
| 15188 | while (m->NATTraversals) |
| 15189 | { |
| 15190 | NATTraversalInfo *t = m->NATTraversals; |
| 15191 | mDNS_StopNATOperation_internal(m, t); // This will cut 't' from the list, thereby advancing m->NATTraversals in the process |
| 15192 | |
| 15193 | // After stopping the NAT Traversal, we zero out the fields. |
| 15194 | // This has particularly important implications for our AutoTunnel records -- |
| 15195 | // when we deregister our AutoTunnel records below, we don't want their mStatus_MemFree |
| 15196 | // handlers to just turn around and attempt to re-register those same records. |
| 15197 | // Clearing t->ExternalPort/t->RequestedPort will cause the mStatus_MemFree callback handlers |
| 15198 | // to not do this. |
| 15199 | t->ExternalAddress = zerov4Addr; |
| 15200 | t->NewAddress = zerov4Addr; |
| 15201 | t->ExternalPort = zeroIPPort; |
| 15202 | t->RequestedPort = zeroIPPort; |
| 15203 | t->Lifetime = 0; |
| 15204 | t->Result = mStatus_NoError; |
| 15205 | } |
| 15206 | |
| 15207 | // Make sure there are nothing but deregistering records remaining in the list |
| 15208 | if (m->CurrentRecord) |
| 15209 | LogMsg("mDNS_StartExit: ERROR m->CurrentRecord already set %s" , ARDisplayString(m, m->CurrentRecord)); |
| 15210 | |
| 15211 | // We're in the process of shutting down, so queries, etc. are no longer available. |
| 15212 | // Consequently, determining certain information, e.g. the uDNS update server's IP |
| 15213 | // address, will not be possible. The records on the main list are more likely to |
| 15214 | // already contain such information, so we deregister the duplicate records first. |
| 15215 | LogInfo("mDNS_StartExit: Deregistering duplicate resource records" ); |
| 15216 | DeregLoop(m, m->DuplicateRecords); |
| 15217 | LogInfo("mDNS_StartExit: Deregistering resource records" ); |
| 15218 | DeregLoop(m, m->ResourceRecords); |
| 15219 | |
| 15220 | // If we scheduled a response to send goodbye packets, we set NextScheduledResponse to now. Normally when deregistering records, |
| 15221 | // we allow up to 100ms delay (to help improve record grouping) but when shutting down we don't want any such delay. |
| 15222 | if (m->NextScheduledResponse - m->timenow < mDNSPlatformOneSecond) |
| 15223 | { |
| 15224 | m->NextScheduledResponse = m->timenow; |
| 15225 | m->SuppressSending = 0; |
| 15226 | } |
| 15227 | |
| 15228 | if (m->ResourceRecords) LogInfo("mDNS_StartExit: Sending final record deregistrations" ); |
| 15229 | else LogInfo("mDNS_StartExit: No deregistering records remain" ); |
| 15230 | |
| 15231 | for (rr = m->DuplicateRecords; rr; rr = rr->next) |
| 15232 | LogMsg("mDNS_StartExit: Should not still have Duplicate Records remaining: %02X %s" , rr->resrec.RecordType, ARDisplayString(m, rr)); |
| 15233 | |
| 15234 | // If any deregistering records remain, send their deregistration announcements before we exit |
| 15235 | if (m->mDNSPlatformStatus != mStatus_NoError) DiscardDeregistrations(m); |
| 15236 | |
| 15237 | mDNS_Unlock(m); |
| 15238 | |
| 15239 | LogInfo("mDNS_StartExit: done" ); |
| 15240 | } |
| 15241 | |
| 15242 | mDNSexport void mDNS_FinalExit(mDNS *const m) |
| 15243 | { |
| 15244 | mDNSu32 rrcache_active = 0; |
| 15245 | mDNSu32 rrcache_totalused = m->rrcache_totalused; |
| 15246 | mDNSu32 slot; |
| 15247 | AuthRecord *rr; |
| 15248 | |
| 15249 | LogInfo("mDNS_FinalExit: mDNSPlatformClose" ); |
| 15250 | mDNSPlatformClose(m); |
| 15251 | |
| 15252 | for (slot = 0; slot < CACHE_HASH_SLOTS; slot++) |
| 15253 | { |
| 15254 | while (m->rrcache_hash[slot]) |
| 15255 | { |
| 15256 | CacheGroup *cg = m->rrcache_hash[slot]; |
| 15257 | while (cg->members) |
| 15258 | { |
| 15259 | CacheRecord *cr = cg->members; |
| 15260 | cg->members = cg->members->next; |
| 15261 | if (cr->CRActiveQuestion) rrcache_active++; |
| 15262 | ReleaseCacheRecord(m, cr); |
| 15263 | } |
| 15264 | cg->rrcache_tail = &cg->members; |
| 15265 | ReleaseCacheGroup(m, &m->rrcache_hash[slot]); |
| 15266 | } |
| 15267 | } |
| 15268 | debugf("mDNS_FinalExit: RR Cache was using %ld records, %lu active" , rrcache_totalused, rrcache_active); |
| 15269 | if (rrcache_active != m->rrcache_active) |
| 15270 | LogMsg("*** ERROR *** rrcache_totalused %lu; rrcache_active %lu != m->rrcache_active %lu" , rrcache_totalused, rrcache_active, m->rrcache_active); |
| 15271 | |
| 15272 | for (rr = m->ResourceRecords; rr; rr = rr->next) |
| 15273 | LogMsg("mDNS_FinalExit failed to send goodbye for: %p %02X %s" , rr, rr->resrec.RecordType, ARDisplayString(m, rr)); |
| 15274 | |
| 15275 | LogInfo("mDNS_FinalExit: done" ); |
| 15276 | } |
| 15277 | |
| 15278 | #ifdef UNIT_TEST |
| 15279 | #include "../unittests/mdns_ut.c" |
| 15280 | #endif |
| 15281 | |